prettier-plugin-curly-and-jsdoc/dist/index.js

Make prettier-plugin-curly and prttier-plugin-jsdoc work together.

import { format } from "prettier";
import parserBabel from "prettier/plugins/babel";
import parserFlow from "prettier/plugins/flow";
import parserTypescript from "prettier/plugins/typescript";

//#region rolldown:runtime
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function() {
	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all$1) => {
	for (var name in all$1) __defProp(target, name, {
		get: all$1[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: ((k) => from[k]).bind(null, key),
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/primitives.js
/** @deprecated */
var Markers;
(function(Markers$1) {
	Markers$1["start"] = "/**";
	Markers$1["nostart"] = "/***";
	Markers$1["delim"] = "*";
	Markers$1["end"] = "*/";
})(Markers = Markers || (Markers = {}));

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/util.js
function isSpace(source) {
	return /^\s+$/.test(source);
}
function splitCR(source) {
	const matches = source.match(/\r+$/);
	return matches == null ? ["", source] : [source.slice(-matches[0].length), source.slice(0, -matches[0].length)];
}
function splitSpace(source) {
	const matches = source.match(/^\s+/);
	return matches == null ? ["", source] : [source.slice(0, matches[0].length), source.slice(matches[0].length)];
}
function splitLines(source) {
	return source.split(/\n/);
}
function seedSpec(spec = {}) {
	return Object.assign({
		tag: "",
		name: "",
		type: "",
		optional: false,
		description: "",
		problems: [],
		source: []
	}, spec);
}
function seedTokens(tokens = {}) {
	return Object.assign({
		start: "",
		delimiter: "",
		postDelimiter: "",
		tag: "",
		postTag: "",
		name: "",
		postName: "",
		type: "",
		postType: "",
		description: "",
		end: "",
		lineEnd: ""
	}, tokens);
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/block-parser.js
const reTag = /^@\S+/;
/**
* Creates configured `Parser`
* @param {Partial<Options>} options
*/
function getParser$2({ fence = "```" } = {}) {
	const fencer = getFencer(fence);
	const toggleFence = (source, isFenced) => fencer(source) ? !isFenced : isFenced;
	return function parseBlock(source) {
		const sections = [[]];
		let isFenced = false;
		for (const line of source) {
			if (reTag.test(line.tokens.description) && !isFenced) sections.push([line]);
			else sections[sections.length - 1].push(line);
			isFenced = toggleFence(line.tokens.description, isFenced);
		}
		return sections;
	};
}
function getFencer(fence) {
	if (typeof fence === "string") return (source) => source.split(fence).length % 2 === 0;
	return fence;
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/source-parser.js
function getParser$3({ startLine = 0, markers = Markers } = {}) {
	let block = null;
	let num = startLine;
	return function parseSource(source) {
		let rest = source;
		const tokens = seedTokens();
		[tokens.lineEnd, rest] = splitCR(rest);
		[tokens.start, rest] = splitSpace(rest);
		if (block === null && rest.startsWith(markers.start) && !rest.startsWith(markers.nostart)) {
			block = [];
			tokens.delimiter = rest.slice(0, markers.start.length);
			rest = rest.slice(markers.start.length);
			[tokens.postDelimiter, rest] = splitSpace(rest);
		}
		if (block === null) {
			num++;
			return null;
		}
		const isClosed = rest.trimRight().endsWith(markers.end);
		if (tokens.delimiter === "" && rest.startsWith(markers.delim) && !rest.startsWith(markers.end)) {
			tokens.delimiter = markers.delim;
			rest = rest.slice(markers.delim.length);
			[tokens.postDelimiter, rest] = splitSpace(rest);
		}
		if (isClosed) {
			const trimmed = rest.trimRight();
			tokens.end = rest.slice(trimmed.length - markers.end.length);
			rest = trimmed.slice(0, -markers.end.length);
		}
		tokens.description = rest;
		block.push({
			number: num,
			source,
			tokens
		});
		num++;
		if (isClosed) {
			const result = block.slice();
			block = null;
			return result;
		}
		return null;
	};
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/spec-parser.js
function getParser$4({ tokenizers: tokenizers$1 }) {
	return function parseSpec(source) {
		var _a;
		let spec = seedSpec({ source });
		for (const tokenize of tokenizers$1) {
			spec = tokenize(spec);
			if ((_a = spec.problems[spec.problems.length - 1]) === null || _a === void 0 ? void 0 : _a.critical) break;
		}
		return spec;
	};
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/tokenizers/tag.js
/**
* Splits the `@prefix` from remaining `Spec.lines[].token.description` into the `tag` token,
* and populates `spec.tag`
*/
function tagTokenizer$1() {
	return (spec) => {
		const { tokens } = spec.source[0];
		const match = tokens.description.match(/\s*(@(\S+))(\s*)/);
		if (match === null) {
			spec.problems.push({
				code: "spec:tag:prefix",
				message: "tag should start with \"@\" symbol",
				line: spec.source[0].number,
				critical: true
			});
			return spec;
		}
		tokens.tag = match[1];
		tokens.postTag = match[3];
		tokens.description = tokens.description.slice(match[0].length);
		spec.tag = match[2];
		return spec;
	};
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/tokenizers/type.js
/**
* Sets splits remaining `Spec.lines[].tokes.description` into `type` and `description`
* tokens and populates Spec.type`
*
* @param {Spacing} spacing tells how to deal with a whitespace
* for type values going over multiple lines
*/
function typeTokenizer$1(spacing = "compact") {
	const join$1 = getJoiner$1(spacing);
	return (spec) => {
		let curlies = 0;
		let lines = [];
		for (const [i, { tokens }] of spec.source.entries()) {
			let type = "";
			if (i === 0 && tokens.description[0] !== "{") return spec;
			for (const ch of tokens.description) {
				if (ch === "{") curlies++;
				if (ch === "}") curlies--;
				type += ch;
				if (curlies === 0) break;
			}
			lines.push([tokens, type]);
			if (curlies === 0) break;
		}
		if (curlies !== 0) {
			spec.problems.push({
				code: "spec:type:unpaired-curlies",
				message: "unpaired curlies",
				line: spec.source[0].number,
				critical: true
			});
			return spec;
		}
		const parts = [];
		const offset = lines[0][0].postDelimiter.length;
		for (const [i, [tokens, type]] of lines.entries()) {
			tokens.type = type;
			if (i > 0) {
				tokens.type = tokens.postDelimiter.slice(offset) + type;
				tokens.postDelimiter = tokens.postDelimiter.slice(0, offset);
			}
			[tokens.postType, tokens.description] = splitSpace(tokens.description.slice(type.length));
			parts.push(tokens.type);
		}
		parts[0] = parts[0].slice(1);
		parts[parts.length - 1] = parts[parts.length - 1].slice(0, -1);
		spec.type = join$1(parts);
		return spec;
	};
}
const trim = (x) => x.trim();
function getJoiner$1(spacing) {
	if (spacing === "compact") return (t) => t.map(trim).join("");
	else if (spacing === "preserve") return (t) => t.join("\n");
	else return spacing;
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/tokenizers/name.js
const isQuoted = (s) => s && s.startsWith("\"") && s.endsWith("\"");
/**
* Splits remaining `spec.lines[].tokens.description` into `name` and `descriptions` tokens,
* and populates the `spec.name`
*/
function nameTokenizer$1() {
	const typeEnd = (num, { tokens }, i) => tokens.type === "" ? num : i;
	return (spec) => {
		const { tokens } = spec.source[spec.source.reduce(typeEnd, 0)];
		const source = tokens.description.trimLeft();
		const quotedGroups = source.split("\"");
		if (quotedGroups.length > 1 && quotedGroups[0] === "" && quotedGroups.length % 2 === 1) {
			spec.name = quotedGroups[1];
			tokens.name = `"${quotedGroups[1]}"`;
			[tokens.postName, tokens.description] = splitSpace(source.slice(tokens.name.length));
			return spec;
		}
		let brackets = 0;
		let name = "";
		let optional = false;
		let defaultValue;
		for (const ch of source) {
			if (brackets === 0 && isSpace(ch)) break;
			if (ch === "[") brackets++;
			if (ch === "]") brackets--;
			name += ch;
		}
		if (brackets !== 0) {
			spec.problems.push({
				code: "spec:name:unpaired-brackets",
				message: "unpaired brackets",
				line: spec.source[0].number,
				critical: true
			});
			return spec;
		}
		const nameToken = name;
		if (name[0] === "[" && name[name.length - 1] === "]") {
			optional = true;
			name = name.slice(1, -1);
			const parts = name.split("=");
			name = parts[0].trim();
			if (parts[1] !== void 0) defaultValue = parts.slice(1).join("=").trim();
			if (name === "") {
				spec.problems.push({
					code: "spec:name:empty-name",
					message: "empty name",
					line: spec.source[0].number,
					critical: true
				});
				return spec;
			}
			if (defaultValue === "") {
				spec.problems.push({
					code: "spec:name:empty-default",
					message: "empty default value",
					line: spec.source[0].number,
					critical: true
				});
				return spec;
			}
			if (!isQuoted(defaultValue) && /=(?!>)/.test(defaultValue)) {
				spec.problems.push({
					code: "spec:name:invalid-default",
					message: "invalid default value syntax",
					line: spec.source[0].number,
					critical: true
				});
				return spec;
			}
		}
		spec.optional = optional;
		spec.name = name;
		tokens.name = nameToken;
		if (defaultValue !== void 0) spec.default = defaultValue;
		[tokens.postName, tokens.description] = splitSpace(source.slice(tokens.name.length));
		return spec;
	};
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/tokenizers/description.js
/**
* Makes no changes to `spec.lines[].tokens` but joins them into `spec.description`
* following given spacing srtategy
* @param {Spacing} spacing tells how to handle the whitespace
* @param {BlockMarkers} markers tells how to handle comment block delimitation
*/
function descriptionTokenizer$1(spacing = "compact", markers = Markers) {
	const join$1 = getJoiner(spacing);
	return (spec) => {
		spec.description = join$1(spec.source, markers);
		return spec;
	};
}
function getJoiner(spacing) {
	if (spacing === "compact") return compactJoiner;
	if (spacing === "preserve") return preserveJoiner;
	return spacing;
}
function compactJoiner(lines, markers = Markers) {
	return lines.map(({ tokens: { description } }) => description.trim()).filter((description) => description !== "").join(" ");
}
const lineNo = (num, { tokens }, i) => tokens.type === "" ? num : i;
const getDescription = ({ tokens }) => (tokens.delimiter === "" ? tokens.start : tokens.postDelimiter.slice(1)) + tokens.description;
function preserveJoiner(lines, markers = Markers) {
	if (lines.length === 0) return "";
	if (lines[0].tokens.description === "" && lines[0].tokens.delimiter === markers.start) lines = lines.slice(1);
	const lastLine = lines[lines.length - 1];
	if (lastLine !== void 0 && lastLine.tokens.description === "" && lastLine.tokens.end.endsWith(markers.end)) lines = lines.slice(0, -1);
	lines = lines.slice(lines.reduce(lineNo, 0));
	return lines.map(getDescription).join("\n");
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/parser/index.js
function getParser$1({ startLine = 0, fence = "```", spacing = "compact", markers = Markers, tokenizers: tokenizers$1 = [
	tagTokenizer$1(),
	typeTokenizer$1(spacing),
	nameTokenizer$1(),
	descriptionTokenizer$1(spacing)
] } = {}) {
	if (startLine < 0 || startLine % 1 > 0) throw new Error("Invalid startLine");
	const parseSource = getParser$3({
		startLine,
		markers
	});
	const parseBlock = getParser$2({ fence });
	const parseSpec = getParser$4({ tokenizers: tokenizers$1 });
	const joinDescription = getJoiner(spacing);
	return function(source) {
		const blocks = [];
		for (const line of splitLines(source)) {
			const lines = parseSource(line);
			if (lines === null) continue;
			const sections = parseBlock(lines);
			const specs = sections.slice(1).map(parseSpec);
			blocks.push({
				description: joinDescription(sections[0], markers),
				tags: specs,
				source: lines,
				problems: specs.reduce((acc, spec) => acc.concat(spec.problems), [])
			});
		}
		return blocks;
	};
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/stringifier/index.js
function join(tokens) {
	return tokens.start + tokens.delimiter + tokens.postDelimiter + tokens.tag + tokens.postTag + tokens.type + tokens.postType + tokens.name + tokens.postName + tokens.description + tokens.end + tokens.lineEnd;
}
function getStringifier() {
	return (block) => block.source.map(({ tokens }) => join(tokens)).join("\n");
}

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/transforms/align.js
var __rest$2 = void 0 && (void 0).__rest || function(s, e) {
	var t = {};
	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
	}
	return t;
};

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/transforms/indent.js
var __rest$1 = void 0 && (void 0).__rest || function(s, e) {
	var t = {};
	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
	}
	return t;
};

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/transforms/crlf.js
var __rest = void 0 && (void 0).__rest || function(s, e) {
	var t = {};
	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
	}
	return t;
};

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/stringifier/inspect.js
const zeroWidth = {
	line: 0,
	start: 0,
	delimiter: 0,
	postDelimiter: 0,
	tag: 0,
	postTag: 0,
	name: 0,
	postName: 0,
	type: 0,
	postType: 0,
	description: 0,
	end: 0,
	lineEnd: 0
};
const fields = Object.keys(zeroWidth);

//#endregion
//#region ../../node_modules/.pnpm/comment-parser@1.4.0/node_modules/comment-parser/es6/index.js
function parse(source, options$1 = {}) {
	return getParser$1(options$1)(source);
}
const stringify$1 = getStringifier();
const tokenizers = {
	tag: tagTokenizer$1,
	type: typeTokenizer$1,
	name: nameTokenizer$1,
	description: descriptionTokenizer$1
};

//#endregion
//#region ../../node_modules/.pnpm/binary-searching@2.0.5/node_modules/binary-searching/search-bounds.js
var require_search_bounds = __commonJS({ "../../node_modules/.pnpm/binary-searching@2.0.5/node_modules/binary-searching/search-bounds.js"(exports, module) {
	function ge(a, y, c, l, h) {
		var i = h + 1;
		while (l <= h) {
			var m = l + h >>> 1, x = a[m];
			var p = c !== void 0 ? c(x, y) : x - y;
			if (p >= 0) {
				i = m;
				h = m - 1;
			} else l = m + 1;
		}
		return i;
	}
	function gt(a, y, c, l, h) {
		var i = h + 1;
		while (l <= h) {
			var m = l + h >>> 1, x = a[m];
			var p = c !== void 0 ? c(x, y) : x - y;
			if (p > 0) {
				i = m;
				h = m - 1;
			} else l = m + 1;
		}
		return i;
	}
	function lt(a, y, c, l, h) {
		var i = l - 1;
		while (l <= h) {
			var m = l + h >>> 1, x = a[m];
			var p = c !== void 0 ? c(x, y) : x - y;
			if (p < 0) {
				i = m;
				l = m + 1;
			} else h = m - 1;
		}
		return i;
	}
	function le(a, y, c, l, h) {
		var i = l - 1;
		while (l <= h) {
			var m = l + h >>> 1, x = a[m];
			var p = c !== void 0 ? c(x, y) : x - y;
			if (p <= 0) {
				i = m;
				l = m + 1;
			} else h = m - 1;
		}
		return i;
	}
	function eq(a, y, c, l, h) {
		while (l <= h) {
			var m = l + h >>> 1, x = a[m];
			var p = c !== void 0 ? c(x, y) : x - y;
			if (p === 0) return m;
			if (p <= 0) l = m + 1;
			else h = m - 1;
		}
		return -1;
	}
	function norm(a, y, c, l, h, f) {
		if (typeof c === "function") return f(a, y, c, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0);
		return f(a, y, void 0, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0);
	}
	module.exports = {
		ge: function(a, y, c, l, h) {
			return norm(a, y, c, l, h, ge);
		},
		gt: function(a, y, c, l, h) {
			return norm(a, y, c, l, h, gt);
		},
		lt: function(a, y, c, l, h) {
			return norm(a, y, c, l, h, lt);
		},
		le: function(a, y, c, l, h) {
			return norm(a, y, c, l, h, le);
		},
		eq: function(a, y, c, l, h) {
			return norm(a, y, c, l, h, eq);
		}
	};
} });

//#endregion
//#region ../../node_modules/.pnpm/prettier-plugin-jsdoc@1.3.2_prettier@3.0.3/node_modules/prettier-plugin-jsdoc/dist/tags.js
const ABSTRACT = "abstract";
const ASYNC = "async";
const AUGMENTS = "augments";
const AUTHOR = "author";
const BORROWS = "borrows";
const CALLBACK = "callback";
const CATEGORY = "category";
const CLASS = "class";
const CONSTANT = "constant";
const DEFAULT = "default";
const DEFAULT_VALUE = "defaultValue";
const DEPRECATED = "deprecated";
const DESCRIPTION = "description";
const EXAMPLE = "example";
const EXTENDS = "extends";
const EXTERNAL = "external";
const FILE = "file";
const FIRES = "fires";
const FLOW = "flow";
const FUNCTION = "function";
const IGNORE = "ignore";
const LICENSE = "license";
const MEMBER = "member";
const MEMBEROF = "memberof";
const MODULE = "module";
const NAMESPACE = "namespace";
const OVERLOAD = "overload";
const OVERRIDE = "override";
const PARAM = "param";
const PRIVATE = "private";
const PRIVATE_REMARKS = "privateRemarks";
const PROPERTY = "property";
const PROVIDES_MODULE = "providesModule";
const REMARKS = "remarks";
const RETURNS = "returns";
const SEE = "see";
const SINCE = "since";
const TEMPLATE = "template";
const THROWS = "throws";
const TODO = "todo";
const TYPE = "type";
const TYPE_PARAM = "typeParam";
const TYPEDEF = "typedef";
const SATISFIES = "satisfies";
const VERSION = "version";
const YIELDS = "yields";
const SPACE_TAG_DATA = {
	tag: "this_is_for_space",
	name: "",
	optional: false,
	type: "",
	description: "",
	source: [],
	problems: []
};

//#endregion
//#region ../../node_modules/.pnpm/prettier-plugin-jsdoc@1.3.2_prettier@3.0.3/node_modules/prettier-plugin-jsdoc/dist/roles.js
const TAGS_SYNONYMS = {
	arg: PARAM,
	argument: PARAM,
	const: CONSTANT,
	constructor: CLASS,
	desc: DESCRIPTION,
	emits: FIRES,
	examples: EXAMPLE,
	exception: THROWS,
	fileoverview: FILE,
	func: FUNCTION,
	host: EXTERNAL,
	method: FUNCTION,
	overview: FILE,
	params: PARAM,
	prop: PROPERTY,
	return: RETURNS,
	var: MEMBER,
	virtual: ABSTRACT,
	yield: YIELDS,
	hidden: IGNORE
};
const TAGS_DEFAULT = [DEFAULT, DEFAULT_VALUE];
const TAGS_NAMELESS = [
	BORROWS,
	CATEGORY,
	DEPRECATED,
	DESCRIPTION,
	EXAMPLE,
	EXTENDS,
	LICENSE,
	MODULE,
	NAMESPACE,
	OVERLOAD,
	OVERRIDE,
	PRIVATE_REMARKS,
	REMARKS,
	RETURNS,
	SINCE,
	THROWS,
	TODO,
	YIELDS,
	FILE,
	...TAGS_DEFAULT
];
const TAGS_TYPELESS = [
	BORROWS,
	BORROWS,
	DEPRECATED,
	DESCRIPTION,
	EXAMPLE,
	IGNORE,
	LICENSE,
	MODULE,
	NAMESPACE,
	OVERLOAD,
	OVERRIDE,
	PRIVATE_REMARKS,
	REMARKS,
	SINCE,
	TODO,
	FILE
];
const TAGS_PEV_FORMATE_DESCRIPTION = [
	BORROWS,
	...TAGS_DEFAULT,
	MEMBEROF,
	MODULE,
	SEE
];
const TAGS_DESCRIPTION_NEEDED = [
	BORROWS,
	CATEGORY,
	DESCRIPTION,
	EXAMPLE,
	PRIVATE_REMARKS,
	REMARKS,
	SINCE,
	TODO
];
const TAGS_VERTICALLY_ALIGN_ABLE = [
	EXTENDS,
	PARAM,
	PROPERTY,
	RETURNS,
	THROWS,
	TYPE,
	SATISFIES,
	TYPEDEF,
	YIELDS
];
const TAGS_GROUP_HEAD = [CALLBACK, TYPEDEF];
const TAGS_GROUP_CONDITION = [
	...TAGS_GROUP_HEAD,
	TYPE,
	PROPERTY,
	PARAM,
	RETURNS,
	YIELDS,
	THROWS
];
const TAGS_ORDER = {
	[REMARKS]: 1,
	[PRIVATE_REMARKS]: 2,
	[PROVIDES_MODULE]: 3,
	[MODULE]: 4,
	[LICENSE]: 5,
	[FLOW]: 6,
	[ASYNC]: 7,
	[PRIVATE]: 8,
	[IGNORE]: 9,
	[MEMBEROF]: 10,
	[VERSION]: 11,
	[FILE]: 12,
	[AUTHOR]: 13,
	[DEPRECATED]: 14,
	[SINCE]: 15,
	[CATEGORY]: 16,
	[DESCRIPTION]: 17,
	[EXAMPLE]: 18,
	[ABSTRACT]: 19,
	[AUGMENTS]: 20,
	[CONSTANT]: 21,
	[DEFAULT]: 22,
	[DEFAULT_VALUE]: 23,
	[EXTERNAL]: 24,
	[OVERLOAD]: 25,
	[FIRES]: 26,
	[TEMPLATE]: 27,
	[TYPE_PARAM]: 28,
	[FUNCTION]: 29,
	[NAMESPACE]: 30,
	[BORROWS]: 31,
	[CLASS]: 32,
	[EXTENDS]: 33,
	[MEMBER]: 34,
	[TYPEDEF]: 35,
	[TYPE]: 36,
	[SATISFIES]: 37,
	[PROPERTY]: 38,
	[CALLBACK]: 39,
	[PARAM]: 40,
	[YIELDS]: 41,
	[RETURNS]: 42,
	[THROWS]: 43,
	other: 44,
	[SEE]: 45,
	[TODO]: 46
};

//#endregion
//#region ../../node_modules/.pnpm/prettier-plugin-jsdoc@1.3.2_prettier@3.0.3/node_modules/prettier-plugin-jsdoc/dist/utils.js
var import_search_bounds = __toESM(require_search_bounds(), 1);
function convertToModernType(oldType) {
	return withoutStrings(oldType, (type) => {
		type = type.trim();
		type = type.replace(/\.</g, "<");
		type = type.replace(/\*/g, " any ");
		type = type.replace(/^\?\s*(\w+)$/, "$1 | null").replace(/^(\w+)\s*\?$/, "$1 | null");
		let changed = true;
		while (changed) {
			changed = false;
			type = type.replace(/(^|[^$\w\xA0-\uFFFF])Array\s*<((?:[^<>=]|=>|=(?!>)|<(?:[^<>=]|=>|=(?!>))+>)+)>/g, (_, prefix, inner) => {
				changed = true;
				return `${prefix}(${inner})[]`;
			});
		}
		return type;
	});
}
function withoutStrings(type, mapFn) {
	const strings = [];
	let modifiedType = type.replace(/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/g, (m) => {
		strings.push(m);
		return `String$${strings.length - 1}$`;
	});
	if (modifiedType.includes("`")) return type;
	modifiedType = mapFn(modifiedType);
	return modifiedType.replace(/String\$(\d+)\$/g, (_, index$1) => strings[index$1]);
}
async function formatType(type, options$1) {
	try {
		const TYPE_START = "type name = ";
		let pretty = type;
		let rest = false;
		if (pretty.startsWith("...")) {
			rest = true;
			pretty = `(${pretty.slice(3)})[]`;
		}
		pretty = await format(`${TYPE_START}${pretty}`, {
			...options$1,
			parser: "typescript",
			plugins: [],
			filepath: "file.ts"
		});
		pretty = pretty.slice(TYPE_START.length);
		pretty = pretty.replace(/^\s*/g, "").replace(/[;\n]*$/g, "").replace(/^\|/g, "").trim();
		if (rest) pretty = "..." + pretty.replace(/\[\s*\]$/, "");
		return pretty;
	} catch (error) {
		return type;
	}
}
function addStarsToTheBeginningOfTheLines(originalComment, comment, options$1) {
	if (options$1.jsdocCommentLineStrategy === "singleLine" && numberOfAStringInString(comment.trim(), "\n") === 0 || options$1.jsdocCommentLineStrategy === "keep" && numberOfAStringInString(originalComment, "\n") === 0) return `* ${comment.trim()} `;
	return `*${comment.replace(/(\n(?!$))/g, "\n * ")}\n `;
}
function numberOfAStringInString(string$2, search$1) {
	return (string$2.match(new RegExp(search$1, "g")) || []).length;
}
function capitalizer(str) {
	if (!str) return str;
	if (str.match(/^https?:\/\//i)) return str;
	if (str.startsWith("- ")) return str.slice(0, 2) + capitalizer(str.slice(2));
	return str[0].toUpperCase() + str.slice(1);
}
function detectEndOfLine(text$2) {
	const counter = {
		"\r": 0,
		"\r\n": 0,
		"\n": 0
	};
	const lineEndPattern = /\r\n?|\n/g;
	let m;
	while (m = lineEndPattern.exec(text$2)) counter[m[0]]++;
	const cr = counter["\r"];
	const crlf = counter["\r\n"];
	const lf = counter["\n"];
	const max = Math.max(cr, crlf, lf);
	if (lf === max) return "lf";
	else if (crlf === max) return "crlf";
	else return "cr";
}
function findTokenIndex(tokens, token) {
	return import_search_bounds.default.eq(tokens, token, (a, b) => {
		if (a.loc.start.line === b.loc.start.line) return a.loc.start.column - b.loc.start.column;
		else return a.loc.start.line - b.loc.start.line;
	});
}
async function formatCode(result, beginningSpace, options$1) {
	const { printWidth, jsdocKeepUnParseAbleExampleIndent } = options$1;
	if (result.split("\n").slice(1).every((v) => !v.trim() || v.startsWith(beginningSpace))) result = result.replace(new RegExp(`\n${beginningSpace.replace(/[\t]/g, "[\\t]")}`, "g"), "\n");
	try {
		let formattedExample = "";
		const examplePrintWith = printWidth - 4;
		if (result.trim().startsWith("{")) formattedExample = await format(result || "", {
			...options$1,
			parser: "json",
			printWidth: examplePrintWith
		});
		else formattedExample = await format(result || "", {
			...options$1,
			printWidth: examplePrintWith
		});
		result = formattedExample.replace(/(^|\n)/g, `\n${beginningSpace}`);
	} catch (err) {
		result = `\n${result.split("\n").map((l) => `${beginningSpace}${jsdocKeepUnParseAbleExampleIndent ? l : l.trim()}`).join("\n")}\n`;
		result = result.replace(/^\n[\s]+\n/g, "\n");
	}
	return result;
}
const findPluginByParser = (parserName, options$1) => {
	const tsPlugin = options$1.plugins.find((plugin) => {
		return typeof plugin === "object" && plugin.name && plugin.parsers && plugin.parsers.hasOwnProperty(parserName);
	});
	return !tsPlugin || tsPlugin.name === "prettier-plugin-jsdoc" || tsPlugin.parsers?.hasOwnProperty("jsdoc-parser") ? void 0 : tsPlugin.parsers?.[parserName];
};
const isDefaultTag = (tag) => TAGS_DEFAULT.includes(tag);

//#endregion
//#region ../../node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.js
/**
* @typedef {import('mdast').Nodes} Nodes
*
* @typedef Options
*   Configuration (optional).
* @property {boolean | null | undefined} [includeImageAlt=true]
*   Whether to use `alt` for `image`s (default: `true`).
* @property {boolean | null | undefined} [includeHtml=true]
*   Whether to use `value` of HTML (default: `true`).
*/
/** @type {Options} */
const emptyOptions = {};
/**
* Get the text content of a node or list of nodes.
*
* Prefers the node’s plain-text fields, otherwise serializes its children,
* and if the given value is an array, serialize the nodes in it.
*
* @param {unknown} [value]
*   Thing to serialize, typically `Node`.
* @param {Options | null | undefined} [options]
*   Configuration (optional).
* @returns {string}
*   Serialized `value`.
*/
function toString(value, options$1) {
	const settings = options$1 || emptyOptions;
	const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true;
	const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true;
	return one(value, includeImageAlt, includeHtml);
}
/**
* One node or several nodes.
*
* @param {unknown} value
*   Thing to serialize.
* @param {boolean} includeImageAlt
*   Include image `alt`s.
* @param {boolean} includeHtml
*   Include HTML.
* @returns {string}
*   Serialized node.
*/
function one(value, includeImageAlt, includeHtml) {
	if (node(value)) {
		if ("value" in value) return value.type === "html" && !includeHtml ? "" : value.value;
		if (includeImageAlt && "alt" in value && value.alt) return value.alt;
		if ("children" in value) return all(value.children, includeImageAlt, includeHtml);
	}
	if (Array.isArray(value)) return all(value, includeImageAlt, includeHtml);
	return "";
}
/**
* Serialize a list of nodes.
*
* @param {Array<unknown>} values
*   Thing to serialize.
* @param {boolean} includeImageAlt
*   Include image `alt`s.
* @param {boolean} includeHtml
*   Include HTML.
* @returns {string}
*   Serialized nodes.
*/
function all(values, includeImageAlt, includeHtml) {
	/** @type {Array<string>} */
	const result = [];
	let index$1 = -1;
	while (++index$1 < values.length) result[index$1] = one(values[index$1], includeImageAlt, includeHtml);
	return result.join("");
}
/**
* Check if `value` looks like a node.
*
* @param {unknown} value
*   Thing.
* @returns {value is Nodes}
*   Whether `value` is a node.
*/
function node(value) {
	return Boolean(value && typeof value === "object");
}

//#endregion
//#region ../../node_modules/.pnpm/character-entities@2.0.2/node_modules/character-entities/index.js
/**
* Map of named character references.
*
* @type {Record<string, string>}
*/
const characterEntities = {
	AElig: "Æ",
	AMP: "&",
	Aacute: "Á",
	Abreve: "Ă",
	Acirc: "Â",
	Acy: "А",
	Afr: "𝔄",
	Agrave: "À",
	Alpha: "Α",
	Amacr: "Ā",
	And: "⩓",
	Aogon: "Ą",
	Aopf: "𝔸",
	ApplyFunction: "⁡",
	Aring: "Å",
	Ascr: "𝒜",
	Assign: "≔",
	Atilde: "Ã",
	Auml: "Ä",
	Backslash: "∖",
	Barv: "⫧",
	Barwed: "⌆",
	Bcy: "Б",
	Because: "∵",
	Bernoullis: "ℬ",
	Beta: "Β",
	Bfr: "𝔅",
	Bopf: "𝔹",
	Breve: "˘",
	Bscr: "ℬ",
	Bumpeq: "≎",
	CHcy: "Ч",
	COPY: "©",
	Cacute: "Ć",
	Cap: "⋒",
	CapitalDifferentialD: "ⅅ",
	Cayleys: "ℭ",
	Ccaron: "Č",
	Ccedil: "Ç",
	Ccirc: "Ĉ",
	Cconint: "∰",
	Cdot: "Ċ",
	Cedilla: "¸",
	CenterDot: "·",
	Cfr: "ℭ",
	Chi: "Χ",
	CircleDot: "⊙",
	CircleMinus: "⊖",
	CirclePlus: "⊕",
	CircleTimes: "⊗",
	ClockwiseContourIntegral: "∲",
	CloseCurlyDoubleQuote: "”",
	CloseCurlyQuote: "’",
	Colon: "∷",
	Colone: "⩴",
	Congruent: "≡",
	Conint: "∯",
	ContourIntegral: "∮",
	Copf: "ℂ",
	Coproduct: "∐",
	CounterClockwiseContourIntegral: "∳",
	Cross: "⨯",
	Cscr: "𝒞",
	Cup: "⋓",
	CupCap: "≍",
	DD: "ⅅ",
	DDotrahd: "⤑",
	DJcy: "Ђ",
	DScy: "Ѕ",
	DZcy: "Џ",
	Dagger: "‡",
	Darr: "↡",
	Dashv: "⫤",
	Dcaron: "Ď",
	Dcy: "Д",
	Del: "∇",
	Delta: "Δ",
	Dfr: "𝔇",
	DiacriticalAcute: "´",
	DiacriticalDot: "˙",
	DiacriticalDoubleAcute: "˝",
	DiacriticalGrave: "`",
	DiacriticalTilde: "˜",
	Diamond: "⋄",
	DifferentialD: "ⅆ",
	Dopf: "𝔻",
	Dot: "¨",
	DotDot: "⃜",
	DotEqual: "≐",
	DoubleContourIntegral: "∯",
	DoubleDot: "¨",
	DoubleDownArrow: "⇓",
	DoubleLeftArrow: "⇐",
	DoubleLeftRightArrow: "⇔",
	DoubleLeftTee: "⫤",
	DoubleLongLeftArrow: "⟸",
	DoubleLongLeftRightArrow: "⟺",
	DoubleLongRightArrow: "⟹",
	DoubleRightArrow: "⇒",
	DoubleRightTee: "⊨",
	DoubleUpArrow: "⇑",
	DoubleUpDownArrow: "⇕",
	DoubleVerticalBar: "∥",
	DownArrow: "↓",
	DownArrowBar: "⤓",
	DownArrowUpArrow: "⇵",
	DownBreve: "̑",
	DownLeftRightVector: "⥐",
	DownLeftTeeVector: "⥞",
	DownLeftVector: "↽",
	DownLeftVectorBar: "⥖",
	DownRightTeeVector: "⥟",
	DownRightVector: "⇁",
	DownRightVectorBar: "⥗",
	DownTee: "⊤",
	DownTeeArrow: "↧",
	Downarrow: "⇓",
	Dscr: "𝒟",
	Dstrok: "Đ",
	ENG: "Ŋ",
	ETH: "Ð",
	Eacute: "É",
	Ecaron: "Ě",
	Ecirc: "Ê",
	Ecy: "Э",
	Edot: "Ė",
	Efr: "𝔈",
	Egrave: "È",
	Element: "∈",
	Emacr: "Ē",
	EmptySmallSquare: "◻",
	EmptyVerySmallSquare: "▫",
	Eogon: "Ę",
	Eopf: "𝔼",
	Epsilon: "Ε",
	Equal: "⩵",
	EqualTilde: "≂",
	Equilibrium: "⇌",
	Escr: "ℰ",
	Esim: "⩳",
	Eta: "Η",
	Euml: "Ë",
	Exists: "∃",
	ExponentialE: "ⅇ",
	Fcy: "Ф",
	Ffr: "𝔉",
	FilledSmallSquare: "◼",
	FilledVerySmallSquare: "▪",
	Fopf: "𝔽",
	ForAll: "∀",
	Fouriertrf: "ℱ",
	Fscr: "ℱ",
	GJcy: "Ѓ",
	GT: ">",
	Gamma: "Γ",
	Gammad: "Ϝ",
	Gbreve: "Ğ",
	Gcedil: "Ģ",
	Gcirc: "Ĝ",
	Gcy: "Г",
	Gdot: "Ġ",
	Gfr: "𝔊",
	Gg: "⋙",
	Gopf: "𝔾",
	GreaterEqual: "≥",
	GreaterEqualLess: "⋛",
	GreaterFullEqual: "≧",
	GreaterGreater: "⪢",
	GreaterLess: "≷",
	GreaterSlantEqual: "⩾",
	GreaterTilde: "≳",
	Gscr: "𝒢",
	Gt: "≫",
	HARDcy: "Ъ",
	Hacek: "ˇ",
	Hat: "^",
	Hcirc: "Ĥ",
	Hfr: "ℌ",
	HilbertSpace: "ℋ",
	Hopf: "ℍ",
	HorizontalLine: "─",
	Hscr: "ℋ",
	Hstrok: "Ħ",
	HumpDownHump: "≎",
	HumpEqual: "≏",
	IEcy: "Е",
	IJlig: "IJ",
	IOcy: "Ё",
	Iacute: "Í",
	Icirc: "Î",
	Icy: "И",
	Idot: "İ",
	Ifr: "ℑ",
	Igrave: "Ì",
	Im: "ℑ",
	Imacr: "Ī",
	ImaginaryI: "ⅈ",
	Implies: "⇒",
	Int: "∬",
	Integral: "∫",
	Intersection: "⋂",
	InvisibleComma: "⁣",
	InvisibleTimes: "⁢",
	Iogon: "Į",
	Iopf: "𝕀",
	Iota: "Ι",
	Iscr: "ℐ",
	Itilde: "Ĩ",
	Iukcy: "І",
	Iuml: "Ï",
	Jcirc: "Ĵ",
	Jcy: "Й",
	Jfr: "𝔍",
	Jopf: "𝕁",
	Jscr: "𝒥",
	Jsercy: "Ј",
	Jukcy: "Є",
	KHcy: "Х",
	KJcy: "Ќ",
	Kappa: "Κ",
	Kcedil: "Ķ",
	Kcy: "К",
	Kfr: "𝔎",
	Kopf: "𝕂",
	Kscr: "𝒦",
	LJcy: "Љ",
	LT: "<",
	Lacute: "Ĺ",
	Lambda: "Λ",
	Lang: "⟪",
	Laplacetrf: "ℒ",
	Larr: "↞",
	Lcaron: "Ľ",
	Lcedil: "Ļ",
	Lcy: "Л",
	LeftAngleBracket: "⟨",
	LeftArrow: "←",
	LeftArrowBar: "⇤",
	LeftArrowRightArrow: "⇆",
	LeftCeiling: "⌈",
	LeftDoubleBracket: "⟦",
	LeftDownTeeVector: "⥡",
	LeftDownVector: "⇃",
	LeftDownVectorBar: "⥙",
	LeftFloor: "⌊",
	LeftRightArrow: "↔",
	LeftRightVector: "⥎",
	LeftTee: "⊣",
	LeftTeeArrow: "↤",
	LeftTeeVector: "⥚",
	LeftTriangle: "⊲",
	LeftTriangleBar: "⧏",
	LeftTriangleEqual: "⊴",
	LeftUpDownVector: "⥑",
	LeftUpTeeVector: "⥠",
	LeftUpVector: "↿",
	LeftUpVectorBar: "⥘",
	LeftVector: "↼",
	LeftVectorBar: "⥒",
	Leftarrow: "⇐",
	Leftrightarrow: "⇔",
	LessEqualGreater: "⋚",
	LessFullEqual: "≦",
	LessGreater: "≶",
	LessLess: "⪡",
	LessSlantEqual: "⩽",
	LessTilde: "≲",
	Lfr: "𝔏",
	Ll: "⋘",
	Lleftarrow: "⇚",
	Lmidot: "Ŀ",
	LongLeftArrow: "⟵",
	LongLeftRightArrow: "⟷",
	LongRightArrow: "⟶",
	Longleftarrow: "⟸",
	Longleftrightarrow: "⟺",
	Longrightarrow: "⟹",
	Lopf: "𝕃",
	LowerLeftArrow: "↙",
	LowerRightArrow: "↘",
	Lscr: "ℒ",
	Lsh: "↰",
	Lstrok: "Ł",
	Lt: "≪",
	Map: "⤅",
	Mcy: "М",
	MediumSpace: " ",
	Mellintrf: "ℳ",
	Mfr: "𝔐",
	MinusPlus: "∓",
	Mopf: "𝕄",
	Mscr: "ℳ",
	Mu: "Μ",
	NJcy: "Њ",
	Nacute: "Ń",
	Ncaron: "Ň",
	Ncedil: "Ņ",
	Ncy: "Н",
	NegativeMediumSpace: "​",
	NegativeThickSpace: "​",
	NegativeThinSpace: "​",
	NegativeVeryThinSpace: "​",
	NestedGreaterGreater: "≫",
	NestedLessLess: "≪",
	NewLine: "\n",
	Nfr: "𝔑",
	NoBreak: "⁠",
	NonBreakingSpace: "\xA0",
	Nopf: "ℕ",
	Not: "⫬",
	NotCongruent: "≢",
	NotCupCap: "≭",
	NotDoubleVerticalBar: "∦",
	NotElement: "∉",
	NotEqual: "≠",
	NotEqualTilde: "≂̸",
	NotExists: "∄",
	NotGreater: "≯",
	NotGreaterEqual: "≱",
	NotGreaterFullEqual: "≧̸",
	NotGreaterGreater: "≫̸",
	NotGreaterLess: "≹",
	NotGreaterSlantEqual: "⩾̸",
	NotGreaterTilde: "≵",
	NotHumpDownHump: "≎̸",
	NotHumpEqual: "≏̸",
	NotLeftTriangle: "⋪",
	NotLeftTriangleBar: "⧏̸",
	NotLeftTriangleEqual: "⋬",
	NotLess: "≮",
	NotLessEqual: "≰",
	NotLessGreater: "≸",
	NotLessLess: "≪̸",
	NotLessSlantEqual: "⩽̸",
	NotLessTilde: "≴",
	NotNestedGreaterGreater: "⪢̸",
	NotNestedLessLess: "⪡̸",
	NotPrecedes: "⊀",
	NotPrecedesEqual: "⪯̸",
	NotPrecedesSlantEqual: "⋠",
	NotReverseElement: "∌",
	NotRightTriangle: "⋫",
	NotRightTriangleBar: "⧐̸",
	NotRightTriangleEqual: "⋭",
	NotSquareSubset: "⊏̸",
	NotSquareSubsetEqual: "⋢",
	NotSquareSuperset: "⊐̸",
	NotSquareSupersetEqual: "⋣",
	NotSubset: "⊂⃒",
	NotSubsetEqual: "⊈",
	NotSucceeds: "⊁",
	NotSucceedsEqual: "⪰̸",
	NotSucceedsSlantEqual: "⋡",
	NotSucceedsTilde: "≿̸",
	NotSuperset: "⊃⃒",
	NotSupersetEqual: "⊉",
	NotTilde: "≁",
	NotTildeEqual: "≄",
	NotTildeFullEqual: "≇",
	NotTildeTilde: "≉",
	NotVerticalBar: "∤",
	Nscr: "𝒩",
	Ntilde: "Ñ",
	Nu: "Ν",
	OElig: "Œ",
	Oacute: "Ó",
	Ocirc: "Ô",
	Ocy: "О",
	Odblac: "Ő",
	Ofr: "𝔒",
	Ograve: "Ò",
	Omacr: "Ō",
	Omega: "Ω",
	Omicron: "Ο",
	Oopf: "𝕆",
	OpenCurlyDoubleQuote: "“",
	OpenCurlyQuote: "‘",
	Or: "⩔",
	Oscr: "𝒪",
	Oslash: "Ø",
	Otilde: "Õ",
	Otimes: "⨷",
	Ouml: "Ö",
	OverBar: "‾",
	OverBrace: "⏞",
	OverBracket: "⎴",
	OverParenthesis: "⏜",
	PartialD: "∂",
	Pcy: "П",
	Pfr: "𝔓",
	Phi: "Φ",
	Pi: "Π",
	PlusMinus: "±",
	Poincareplane: "ℌ",
	Popf: "ℙ",
	Pr: "⪻",
	Precedes: "≺",
	PrecedesEqual: "⪯",
	PrecedesSlantEqual: "≼",
	PrecedesTilde: "≾",
	Prime: "″",
	Product: "∏",
	Proportion: "∷",
	Proportional: "∝",
	Pscr: "𝒫",
	Psi: "Ψ",
	QUOT: "\"",
	Qfr: "𝔔",
	Qopf: "ℚ",
	Qscr: "𝒬",
	RBarr: "⤐",
	REG: "®",
	Racute: "Ŕ",
	Rang: "⟫",
	Rarr: "↠",
	Rarrtl: "⤖",
	Rcaron: "Ř",
	Rcedil: "Ŗ",
	Rcy: "Р",
	Re: "ℜ",
	ReverseElement: "∋",
	ReverseEquilibrium: "⇋",
	ReverseUpEquilibrium: "⥯",
	Rfr: "ℜ",
	Rho: "Ρ",
	RightAngleBracket: "⟩",
	RightArrow: "→",
	RightArrowBar: "⇥",
	RightArrowLeftArrow: "⇄",
	RightCeiling: "⌉",
	RightDoubleBracket: "⟧",
	RightDownTeeVector: "⥝",
	RightDownVector: "⇂",
	RightDownVectorBar: "⥕",
	RightFloor: "⌋",
	RightTee: "⊢",
	RightTeeArrow: "↦",
	RightTeeVector: "⥛",
	RightTriangle: "⊳",
	RightTriangleBar: "⧐",
	RightTriangleEqual: "⊵",
	RightUpDownVector: "⥏",
	RightUpTeeVector: "⥜",
	RightUpVector: "↾",
	RightUpVectorBar: "⥔",
	RightVector: "⇀",
	RightVectorBar: "⥓",
	Rightarrow: "⇒",
	Ropf: "ℝ",
	RoundImplies: "⥰",
	Rrightarrow: "⇛",
	Rscr: "ℛ",
	Rsh: "↱",
	RuleDelayed: "⧴",
	SHCHcy: "Щ",
	SHcy: "Ш",
	SOFTcy: "Ь",
	Sacute: "Ś",
	Sc: "⪼",
	Scaron: "Š",
	Scedil: "Ş",
	Scirc: "Ŝ",
	Scy: "С",
	Sfr: "𝔖",
	ShortDownArrow: "↓",
	ShortLeftArrow: "←",
	ShortRightArrow: "→",
	ShortUpArrow: "↑",
	Sigma: "Σ",
	SmallCircle: "∘",
	Sopf: "𝕊",
	Sqrt: "√",
	Square: "□",
	SquareIntersection: "⊓",
	SquareSubset: "⊏",
	SquareSubsetEqual: "⊑",
	SquareSuperset: "⊐",
	SquareSupersetEqual: "⊒",
	SquareUnion: "⊔",
	Sscr: "𝒮",
	Star: "⋆",
	Sub: "⋐",
	Subset: "⋐",
	SubsetEqual: "⊆",
	Succeeds: "≻",
	SucceedsEqual: "⪰",
	SucceedsSlantEqual: "≽",
	SucceedsTilde: "≿",
	SuchThat: "∋",
	Sum: "∑",
	Sup: "⋑",
	Superset: "⊃",
	SupersetEqual: "⊇",
	Supset: "⋑",
	THORN: "Þ",
	TRADE: "™",
	TSHcy: "Ћ",
	TScy: "Ц",
	Tab: "	",
	Tau: "Τ",
	Tcaron: "Ť",
	Tcedil: "Ţ",
	Tcy: "Т",
	Tfr: "𝔗",
	Therefore: "∴",
	Theta: "Θ",
	ThickSpace: "  ",
	ThinSpace: " ",
	Tilde: "∼",
	TildeEqual: "≃",
	TildeFullEqual: "≅",
	TildeTilde: "≈",
	Topf: "𝕋",
	TripleDot: "⃛",
	Tscr: "𝒯",
	Tstrok: "Ŧ",
	Uacute: "Ú",
	Uarr: "↟",
	Uarrocir: "⥉",
	Ubrcy: "Ў",
	Ubreve: "Ŭ",
	Ucirc: "Û",
	Ucy: "У",
	Udblac: "Ű",
	Ufr: "𝔘",
	Ugrave: "Ù",
	Umacr: "Ū",
	UnderBar: "_",
	UnderBrace: "⏟",
	UnderBracket: "⎵",
	UnderParenthesis: "⏝",
	Union: "⋃",
	UnionPlus: "⊎",
	Uogon: "Ų",
	Uopf: "𝕌",
	UpArrow: "↑",
	UpArrowBar: "⤒",
	UpArrowDownArrow: "⇅",
	UpDownArrow: "↕",
	UpEquilibrium: "⥮",
	UpTee: "⊥",
	UpTeeArrow: "↥",
	Uparrow: "⇑",
	Updownarrow: "⇕",
	UpperLeftArrow: "↖",
	UpperRightArrow: "↗",
	Upsi: "ϒ",
	Upsilon: "Υ",
	Uring: "Ů",
	Uscr: "𝒰",
	Utilde: "Ũ",
	Uuml: "Ü",
	VDash: "⊫",
	Vbar: "⫫",
	Vcy: "В",
	Vdash: "⊩",
	Vdashl: "⫦",
	Vee: "⋁",
	Verbar: "‖",
	Vert: "‖",
	VerticalBar: "∣",
	VerticalLine: "|",
	VerticalSeparator: "❘",
	VerticalTilde: "≀",
	VeryThinSpace: " ",
	Vfr: "𝔙",
	Vopf: "𝕍",
	Vscr: "𝒱",
	Vvdash: "⊪",
	Wcirc: "Ŵ",
	Wedge: "⋀",
	Wfr: "𝔚",
	Wopf: "𝕎",
	Wscr: "𝒲",
	Xfr: "𝔛",
	Xi: "Ξ",
	Xopf: "𝕏",
	Xscr: "𝒳",
	YAcy: "Я",
	YIcy: "Ї",
	YUcy: "Ю",
	Yacute: "Ý",
	Ycirc: "Ŷ",
	Ycy: "Ы",
	Yfr: "𝔜",
	Yopf: "𝕐",
	Yscr: "𝒴",
	Yuml: "Ÿ",
	ZHcy: "Ж",
	Zacute: "Ź",
	Zcaron: "Ž",
	Zcy: "З",
	Zdot: "Ż",
	ZeroWidthSpace: "​",
	Zeta: "Ζ",
	Zfr: "ℨ",
	Zopf: "ℤ",
	Zscr: "𝒵",
	aacute: "á",
	abreve: "ă",
	ac: "∾",
	acE: "∾̳",
	acd: "∿",
	acirc: "â",
	acute: "´",
	acy: "а",
	aelig: "æ",
	af: "⁡",
	afr: "𝔞",
	agrave: "à",
	alefsym: "ℵ",
	aleph: "ℵ",
	alpha: "α",
	amacr: "ā",
	amalg: "⨿",
	amp: "&",
	and: "∧",
	andand: "⩕",
	andd: "⩜",
	andslope: "⩘",
	andv: "⩚",
	ang: "∠",
	ange: "⦤",
	angle: "∠",
	angmsd: "∡",
	angmsdaa: "⦨",
	angmsdab: "⦩",
	angmsdac: "⦪",
	angmsdad: "⦫",
	angmsdae: "⦬",
	angmsdaf: "⦭",
	angmsdag: "⦮",
	angmsdah: "⦯",
	angrt: "∟",
	angrtvb: "⊾",
	angrtvbd: "⦝",
	angsph: "∢",
	angst: "Å",
	angzarr: "⍼",
	aogon: "ą",
	aopf: "𝕒",
	ap: "≈",
	apE: "⩰",
	apacir: "⩯",
	ape: "≊",
	apid: "≋",
	apos: "'",
	approx: "≈",
	approxeq: "≊",
	aring: "å",
	ascr: "𝒶",
	ast: "*",
	asymp: "≈",
	asympeq: "≍",
	atilde: "ã",
	auml: "ä",
	awconint: "∳",
	awint: "⨑",
	bNot: "⫭",
	backcong: "≌",
	backepsilon: "϶",
	backprime: "‵",
	backsim: "∽",
	backsimeq: "⋍",
	barvee: "⊽",
	barwed: "⌅",
	barwedge: "⌅",
	bbrk: "⎵",
	bbrktbrk: "⎶",
	bcong: "≌",
	bcy: "б",
	bdquo: "„",
	becaus: "∵",
	because: "∵",
	bemptyv: "⦰",
	bepsi: "϶",
	bernou: "ℬ",
	beta: "β",
	beth: "ℶ",
	between: "≬",
	bfr: "𝔟",
	bigcap: "⋂",
	bigcirc: "◯",
	bigcup: "⋃",
	bigodot: "⨀",
	bigoplus: "⨁",
	bigotimes: "⨂",
	bigsqcup: "⨆",
	bigstar: "★",
	bigtriangledown: "▽",
	bigtriangleup: "△",
	biguplus: "⨄",
	bigvee: "⋁",
	bigwedge: "⋀",
	bkarow: "⤍",
	blacklozenge: "⧫",
	blacksquare: "▪",
	blacktriangle: "▴",
	blacktriangledown: "▾",
	blacktriangleleft: "◂",
	blacktriangleright: "▸",
	blank: "␣",
	blk12: "▒",
	blk14: "░",
	blk34: "▓",
	block: "█",
	bne: "=⃥",
	bnequiv: "≡⃥",
	bnot: "⌐",
	bopf: "𝕓",
	bot: "⊥",
	bottom: "⊥",
	bowtie: "⋈",
	boxDL: "╗",
	boxDR: "╔",
	boxDl: "╖",
	boxDr: "╓",
	boxH: "═",
	boxHD: "╦",
	boxHU: "╩",
	boxHd: "╤",
	boxHu: "╧",
	boxUL: "╝",
	boxUR: "╚",
	boxUl: "╜",
	boxUr: "╙",
	boxV: "║",
	boxVH: "╬",
	boxVL: "╣",
	boxVR: "╠",
	boxVh: "╫",
	boxVl: "╢",
	boxVr: "╟",
	boxbox: "⧉",
	boxdL: "╕",
	boxdR: "╒",
	boxdl: "┐",
	boxdr: "┌",
	boxh: "─",
	boxhD: "╥",
	boxhU: "╨",
	boxhd: "┬",
	boxhu: "┴",
	boxminus: "⊟",
	boxplus: "⊞",
	boxtimes: "⊠",
	boxuL: "╛",
	boxuR: "╘",
	boxul: "┘",
	boxur: "└",
	boxv: "│",
	boxvH: "╪",
	boxvL: "╡",
	boxvR: "╞",
	boxvh: "┼",
	boxvl: "┤",
	boxvr: "├",
	bprime: "‵",
	breve: "˘",
	brvbar: "¦",
	bscr: "𝒷",
	bsemi: "⁏",
	bsim: "∽",
	bsime: "⋍",
	bsol: "\\",
	bsolb: "⧅",
	bsolhsub: "⟈",
	bull: "•",
	bullet: "•",
	bump: "≎",
	bumpE: "⪮",
	bumpe: "≏",
	bumpeq: "≏",
	cacute: "ć",
	cap: "∩",
	capand: "⩄",
	capbrcup: "⩉",
	capcap: "⩋",
	capcup: "⩇",
	capdot: "⩀",
	caps: "∩︀",
	caret: "⁁",
	caron: "ˇ",
	ccaps: "⩍",
	ccaron: "č",
	ccedil: "ç",
	ccirc: "ĉ",
	ccups: "⩌",
	ccupssm: "⩐",
	cdot: "ċ",
	cedil: "¸",
	cemptyv: "⦲",
	cent: "¢",
	centerdot: "·",
	cfr: "𝔠",
	chcy: "ч",
	check: "✓",
	checkmark: "✓",
	chi: "χ",
	cir: "○",
	cirE: "⧃",
	circ: "ˆ",
	circeq: "≗",
	circlearrowleft: "↺",
	circlearrowright: "↻",
	circledR: "®",
	circledS: "Ⓢ",
	circledast: "⊛",
	circledcirc: "⊚",
	circleddash: "⊝",
	cire: "≗",
	cirfnint: "⨐",
	cirmid: "⫯",
	cirscir: "⧂",
	clubs: "♣",
	clubsuit: "♣",
	colon: ":",
	colone: "≔",
	coloneq: "≔",
	comma: ",",
	commat: "@",
	comp: "∁",
	compfn: "∘",
	complement: "∁",
	complexes: "ℂ",
	cong: "≅",
	congdot: "⩭",
	conint: "∮",
	copf: "𝕔",
	coprod: "∐",
	copy: "©",
	copysr: "℗",
	crarr: "↵",
	cross: "✗",
	cscr: "𝒸",
	csub: "⫏",
	csube: "⫑",
	csup: "⫐",
	csupe: "⫒",
	ctdot: "⋯",
	cudarrl: "⤸",
	cudarrr: "⤵",
	cuepr: "⋞",
	cuesc: "⋟",
	cularr: "↶",
	cularrp: "⤽",
	cup: "∪",
	cupbrcap: "⩈",
	cupcap: "⩆",
	cupcup: "⩊",
	cupdot: "⊍",
	cupor: "⩅",
	cups: "∪︀",
	curarr: "↷",
	curarrm: "⤼",
	curlyeqprec: "⋞",
	curlyeqsucc: "⋟",
	curlyvee: "⋎",
	curlywedge: "⋏",
	curren: "¤",
	curvearrowleft: "↶",
	curvearrowright: "↷",
	cuvee: "⋎",
	cuwed: "⋏",
	cwconint: "∲",
	cwint: "∱",
	cylcty: "⌭",
	dArr: "⇓",
	dHar: "⥥",
	dagger: "†",
	daleth: "ℸ",
	darr: "↓",
	dash: "‐",
	dashv: "⊣",
	dbkarow: "⤏",
	dblac: "˝",
	dcaron: "ď",
	dcy: "д",
	dd: "ⅆ",
	ddagger: "‡",
	ddarr: "⇊",
	ddotseq: "⩷",
	deg: "°",
	delta: "δ",
	demptyv: "⦱",
	dfisht: "⥿",
	dfr: "𝔡",
	dharl: "⇃",
	dharr: "⇂",
	diam: "⋄",
	diamond: "⋄",
	diamondsuit: "♦",
	diams: "♦",
	die: "¨",
	digamma: "ϝ",
	disin: "⋲",
	div: "÷",
	divide: "÷",
	divideontimes: "⋇",
	divonx: "⋇",
	djcy: "ђ",
	dlcorn: "⌞",
	dlcrop: "⌍",
	dollar: "$",
	dopf: "𝕕",
	dot: "˙",
	doteq: "≐",
	doteqdot: "≑",
	dotminus: "∸",
	dotplus: "∔",
	dotsquare: "⊡",
	doublebarwedge: "⌆",
	downarrow: "↓",
	downdownarrows: "⇊",
	downharpoonleft: "⇃",
	downharpoonright: "⇂",
	drbkarow: "⤐",
	drcorn: "⌟",
	drcrop: "⌌",
	dscr: "𝒹",
	dscy: "ѕ",
	dsol: "⧶",
	dstrok: "đ",
	dtdot: "⋱",
	dtri: "▿",
	dtrif: "▾",
	duarr: "⇵",
	duhar: "⥯",
	dwangle: "⦦",
	dzcy: "џ",
	dzigrarr: "⟿",
	eDDot: "⩷",
	eDot: "≑",
	eacute: "é",
	easter: "⩮",
	ecaron: "ě",
	ecir: "≖",
	ecirc: "ê",
	ecolon: "≕",
	ecy: "э",
	edot: "ė",
	ee: "ⅇ",
	efDot: "≒",
	efr: "𝔢",
	eg: "⪚",
	egrave: "è",
	egs: "⪖",
	egsdot: "⪘",
	el: "⪙",
	elinters: "⏧",
	ell: "ℓ",
	els: "⪕",
	elsdot: "⪗",
	emacr: "ē",
	empty: "∅",
	emptyset: "∅",
	emptyv: "∅",
	emsp13: " ",
	emsp14: " ",
	emsp: " ",
	eng: "ŋ",
	ensp: " ",
	eogon: "ę",
	eopf: "𝕖",
	epar: "⋕",
	eparsl: "⧣",
	eplus: "⩱",
	epsi: "ε",
	epsilon: "ε",
	epsiv: "ϵ",
	eqcirc: "≖",
	eqcolon: "≕",
	eqsim: "≂",
	eqslantgtr: "⪖",
	eqslantless: "⪕",
	equals: "=",
	equest: "≟",
	equiv: "≡",
	equivDD: "⩸",
	eqvparsl: "⧥",
	erDot: "≓",
	erarr: "⥱",
	escr: "ℯ",
	esdot: "≐",
	esim: "≂",
	eta: "η",
	eth: "ð",
	euml: "ë",
	euro: "€",
	excl: "!",
	exist: "∃",
	expectation: "ℰ",
	exponentiale: "ⅇ",
	fallingdotseq: "≒",
	fcy: "ф",
	female: "♀",
	ffilig: "ffi",
	fflig: "ff",
	ffllig: "ffl",
	ffr: "𝔣",
	filig: "fi",
	fjlig: "fj",
	flat: "♭",
	fllig: "fl",
	fltns: "▱",
	fnof: "ƒ",
	fopf: "𝕗",
	forall: "∀",
	fork: "⋔",
	forkv: "⫙",
	fpartint: "⨍",
	frac12: "½",
	frac13: "⅓",
	frac14: "¼",
	frac15: "⅕",
	frac16: "⅙",
	frac18: "⅛",
	frac23: "⅔",
	frac25: "⅖",
	frac34: "¾",
	frac35: "⅗",
	frac38: "⅜",
	frac45: "⅘",
	frac56: "⅚",
	frac58: "⅝",
	frac78: "⅞",
	frasl: "⁄",
	frown: "⌢",
	fscr: "𝒻",
	gE: "≧",
	gEl: "⪌",
	gacute: "ǵ",
	gamma: "γ",
	gammad: "ϝ",
	gap: "⪆",
	gbreve: "ğ",
	gcirc: "ĝ",
	gcy: "г",
	gdot: "ġ",
	ge: "≥",
	gel: "⋛",
	geq: "≥",
	geqq: "≧",
	geqslant: "⩾",
	ges: "⩾",
	gescc: "⪩",
	gesdot: "⪀",
	gesdoto: "⪂",
	gesdotol: "⪄",
	gesl: "⋛︀",
	gesles: "⪔",
	gfr: "𝔤",
	gg: "≫",
	ggg: "⋙",
	gimel: "ℷ",
	gjcy: "ѓ",
	gl: "≷",
	glE: "⪒",
	gla: "⪥",
	glj: "⪤",
	gnE: "≩",
	gnap: "⪊",
	gnapprox: "⪊",
	gne: "⪈",
	gneq: "⪈",
	gneqq: "≩",
	gnsim: "⋧",
	gopf: "𝕘",
	grave: "`",
	gscr: "ℊ",
	gsim: "≳",
	gsime: "⪎",
	gsiml: "⪐",
	gt: ">",
	gtcc: "⪧",
	gtcir: "⩺",
	gtdot: "⋗",
	gtlPar: "⦕",
	gtquest: "⩼",
	gtrapprox: "⪆",
	gtrarr: "⥸",
	gtrdot: "⋗",
	gtreqless: "⋛",
	gtreqqless: "⪌",
	gtrless: "≷",
	gtrsim: "≳",
	gvertneqq: "≩︀",
	gvnE: "≩︀",
	hArr: "⇔",
	hairsp: " ",
	half: "½",
	hamilt: "ℋ",
	hardcy: "ъ",
	harr: "↔",
	harrcir: "⥈",
	harrw: "↭",
	hbar: "ℏ",
	hcirc: "ĥ",
	hearts: "♥",
	heartsuit: "♥",
	hellip: "…",
	hercon: "⊹",
	hfr: "𝔥",
	hksearow: "⤥",
	hkswarow: "⤦",
	hoarr: "⇿",
	homtht: "∻",
	hookleftarrow: "↩",
	hookrightarrow: "↪",
	hopf: "𝕙",
	horbar: "―",
	hscr: "𝒽",
	hslash: "ℏ",
	hstrok: "ħ",
	hybull: "⁃",
	hyphen: "‐",
	iacute: "í",
	ic: "⁣",
	icirc: "î",
	icy: "и",
	iecy: "е",
	iexcl: "¡",
	iff: "⇔",
	ifr: "𝔦",
	igrave: "ì",
	ii: "ⅈ",
	iiiint: "⨌",
	iiint: "∭",
	iinfin: "⧜",
	iiota: "℩",
	ijlig: "ij",
	imacr: "ī",
	image: "ℑ",
	imagline: "ℐ",
	imagpart: "ℑ",
	imath: "ı",
	imof: "⊷",
	imped: "Ƶ",
	in: "∈",
	incare: "℅",
	infin: "∞",
	infintie: "⧝",
	inodot: "ı",
	int: "∫",
	intcal: "⊺",
	integers: "ℤ",
	intercal: "⊺",
	intlarhk: "⨗",
	intprod: "⨼",
	iocy: "ё",
	iogon: "į",
	iopf: "𝕚",
	iota: "ι",
	iprod: "⨼",
	iquest: "¿",
	iscr: "𝒾",
	isin: "∈",
	isinE: "⋹",
	isindot: "⋵",
	isins: "⋴",
	isinsv: "⋳",
	isinv: "∈",
	it: "⁢",
	itilde: "ĩ",
	iukcy: "і",
	iuml: "ï",
	jcirc: "ĵ",
	jcy: "й",
	jfr: "𝔧",
	jmath: "ȷ",
	jopf: "𝕛",
	jscr: "𝒿",
	jsercy: "ј",
	jukcy: "є",
	kappa: "κ",
	kappav: "ϰ",
	kcedil: "ķ",
	kcy: "к",
	kfr: "𝔨",
	kgreen: "ĸ",
	khcy: "х",
	kjcy: "ќ",
	kopf: "𝕜",
	kscr: "𝓀",
	lAarr: "⇚",
	lArr: "⇐",
	lAtail: "⤛",
	lBarr: "⤎",
	lE: "≦",
	lEg: "⪋",
	lHar: "⥢",
	lacute: "ĺ",
	laemptyv: "⦴",
	lagran: "ℒ",
	lambda: "λ",
	lang: "⟨",
	langd: "⦑",
	langle: "⟨",
	lap: "⪅",
	laquo: "«",
	larr: "←",
	larrb: "⇤",
	larrbfs: "⤟",
	larrfs: "⤝",
	larrhk: "↩",
	larrlp: "↫",
	larrpl: "⤹",
	larrsim: "⥳",
	larrtl: "↢",
	lat: "⪫",
	latail: "⤙",
	late: "⪭",
	lates: "⪭︀",
	lbarr: "⤌",
	lbbrk: "❲",
	lbrace: "{",
	lbrack: "[",
	lbrke: "⦋",
	lbrksld: "⦏",
	lbrkslu: "⦍",
	lcaron: "ľ",
	lcedil: "ļ",
	lceil: "⌈",
	lcub: "{",
	lcy: "л",
	ldca: "⤶",
	ldquo: "“",
	ldquor: "„",
	ldrdhar: "⥧",
	ldrushar: "⥋",
	ldsh: "↲",
	le: "≤",
	leftarrow: "←",
	leftarrowtail: "↢",
	leftharpoondown: "↽",
	leftharpoonup: "↼",
	leftleftarrows: "⇇",
	leftrightarrow: "↔",
	leftrightarrows: "⇆",
	leftrightharpoons: "⇋",
	leftrightsquigarrow: "↭",
	leftthreetimes: "⋋",
	leg: "⋚",
	leq: "≤",
	leqq: "≦",
	leqslant: "⩽",
	les: "⩽",
	lescc: "⪨",
	lesdot: "⩿",
	lesdoto: "⪁",
	lesdotor: "⪃",
	lesg: "⋚︀",
	lesges: "⪓",
	lessapprox: "⪅",
	lessdot: "⋖",
	lesseqgtr: "⋚",
	lesseqqgtr: "⪋",
	lessgtr: "≶",
	lesssim: "≲",
	lfisht: "⥼",
	lfloor: "⌊",
	lfr: "𝔩",
	lg: "≶",
	lgE: "⪑",
	lhard: "↽",
	lharu: "↼",
	lharul: "⥪",
	lhblk: "▄",
	ljcy: "љ",
	ll: "≪",
	llarr: "⇇",
	llcorner: "⌞",
	llhard: "⥫",
	lltri: "◺",
	lmidot: "ŀ",
	lmoust: "⎰",
	lmoustache: "⎰",
	lnE: "≨",
	lnap: "⪉",
	lnapprox: "⪉",
	lne: "⪇",
	lneq: "⪇",
	lneqq: "≨",
	lnsim: "⋦",
	loang: "⟬",
	loarr: "⇽",
	lobrk: "⟦",
	longleftarrow: "⟵",
	longleftrightarrow: "⟷",
	longmapsto: "⟼",
	longrightarrow: "⟶",
	looparrowleft: "↫",
	looparrowright: "↬",
	lopar: "⦅",
	lopf: "𝕝",
	loplus: "⨭",
	lotimes: "⨴",
	lowast: "∗",
	lowbar: "_",
	loz: "◊",
	lozenge: "◊",
	lozf: "⧫",
	lpar: "(",
	lparlt: "⦓",
	lrarr: "⇆",
	lrcorner: "⌟",
	lrhar: "⇋",
	lrhard: "⥭",
	lrm: "‎",
	lrtri: "⊿",
	lsaquo: "‹",
	lscr: "𝓁",
	lsh: "↰",
	lsim: "≲",
	lsime: "⪍",
	lsimg: "⪏",
	lsqb: "[",
	lsquo: "‘",
	lsquor: "‚",
	lstrok: "ł",
	lt: "<",
	ltcc: "⪦",
	ltcir: "⩹",
	ltdot: "⋖",
	lthree: "⋋",
	ltimes: "⋉",
	ltlarr: "⥶",
	ltquest: "⩻",
	ltrPar: "⦖",
	ltri: "◃",
	ltrie: "⊴",
	ltrif: "◂",
	lurdshar: "⥊",
	luruhar: "⥦",
	lvertneqq: "≨︀",
	lvnE: "≨︀",
	mDDot: "∺",
	macr: "¯",
	male: "♂",
	malt: "✠",
	maltese: "✠",
	map: "↦",
	mapsto: "↦",
	mapstodown: "↧",
	mapstoleft: "↤",
	mapstoup: "↥",
	marker: "▮",
	mcomma: "⨩",
	mcy: "м",
	mdash: "—",
	measuredangle: "∡",
	mfr: "𝔪",
	mho: "℧",
	micro: "µ",
	mid: "∣",
	midast: "*",
	midcir: "⫰",
	middot: "·