commit 0852e1b2ae033b2a3ef3628d85a9933f3754f992
Author: Remy Noulin <loader2x@gmail.com>
Date: Tue, 23 Apr 2019 08:49:27 +0200
md2html converter
.gitignore | 65 ++
README.md | 14 +
cmdline.c | 296 ++++++++
cmdline.h | 86 +++
entity.c | 2190 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
entity.h | 42 ++
md2html.c | 350 +++++++++
package.yml | 30 +
render_html.c | 490 +++++++++++++
render_html.h | 57 ++
10 files changed, 3620 insertions(+)
Diffstat:
| A | .gitignore | | | 65 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | README.md | | | 14 | ++++++++++++++ |
| A | cmdline.c | | | 296 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | cmdline.h | | | 86 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | entity.c | | | 2190 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | entity.h | | | 42 | ++++++++++++++++++++++++++++++++++++++++++ |
| A | md2html.c | | | 350 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | package.yml | | | 30 | ++++++++++++++++++++++++++++++ |
| A | render_html.c | | | 490 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | render_html.h | | | 57 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
10 files changed, 3620 insertions(+), 0 deletions(-)
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,65 @@
+shpPackages
+
+# Vim
+*.sw*
+
+# Debug
+.gdb_history
+
+# Coverage
+*.gcov
+*.gcda
+*.gcno
+
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
diff --git a/README.md b/README.md
@@ -0,0 +1,14 @@
+# Sheepy
+This is a sheepy package for [sheepy](https://github.com/RemyNoulin/sheepy) and using [libsheepy](https://github.com/RemyNoulin/libsheepy)
+
+# md2html
+
+Convert markdown files to HTML
+
+# Usage
+
+Install with spm: `spm -g install md2html`
+
+```
+md2html markdownFile.md
+```
diff --git a/cmdline.c b/cmdline.c
@@ -0,0 +1,296 @@
+/* cmdline.c: a reentrant version of getopt(). Written 2006 by Brian
+ * Raiter. This code is in the public domain.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include "cmdline.h"
+
+#define docallback(opt, val) \
+ do { if ((r = callback(opt, val, data)) != 0) return r; } while (0)
+
+/* Parse the given cmdline arguments.
+ */
+int readoptions(option const* list, int argc, char **argv,
+ int (*callback)(int, char const*, void*), void *data)
+{
+ char argstring[] = "--";
+ option const *opt;
+ char const *val;
+ char const *p;
+ int stop = 0;
+ int argi, len, r;
+
+ if (!list || !callback)
+ return -1;
+
+ for (argi = 1 ; argi < argc ; ++argi)
+ {
+ /* First, check for "--", which forces all remaining arguments
+ * to be treated as non-options.
+ */
+ if (!stop && argv[argi][0] == '-' && argv[argi][1] == '-'
+ && argv[argi][2] == '\0') {
+ stop = 1;
+ continue;
+ }
+
+ /* Arguments that do not begin with '-' (or are only "-") are
+ * not options.
+ */
+ if (stop || argv[argi][0] != '-' || argv[argi][1] == '\0') {
+ docallback(0, argv[argi]);
+ continue;
+ }
+
+ if (argv[argi][1] == '-')
+ {
+ /* Arguments that begin with a double-dash are long
+ * options.
+ */
+ p = argv[argi] + 2;
+ val = strchr(p, '=');
+ if (val)
+ len = val++ - p;
+ else
+ len = strlen(p);
+
+ /* Is it on the list of valid options? If so, does it
+ * expect a parameter?
+ */
+ for (opt = list ; opt->optval ; ++opt)
+ if (opt->name && !strncmp(p, opt->name, len)
+ && !opt->name[len])
+ break;
+ if (!opt->optval) {
+ docallback('?', argv[argi]);
+ } else if (!val && opt->arg == 1) {
+ docallback(':', argv[argi]);
+ } else if (val && opt->arg == 0) {
+ docallback('=', argv[argi]);
+ } else {
+ docallback(opt->optval, val);
+ }
+ }
+ else
+ {
+ /* Arguments that begin with a single dash contain one or
+ * more short options. Each character in the argument is
+ * examined in turn, unless a parameter consumes the rest
+ * of the argument (or possibly even the following
+ * argument).
+ */
+ for (p = argv[argi] + 1 ; *p ; ++p) {
+ for (opt = list ; opt->optval ; ++opt)
+ if (opt->chname == *p)
+ break;
+ if (!opt->optval) {
+ argstring[1] = *p;
+ docallback('?', argstring);
+ continue;
+ } else if (opt->arg == 0) {
+ docallback(opt->optval, NULL);
+ continue;
+ } else if (p[1]) {
+ docallback(opt->optval, p + 1);
+ break;
+ } else if (argi + 1 < argc && strcmp(argv[argi + 1], "--")) {
+ ++argi;
+ docallback(opt->optval, argv[argi]);
+ break;
+ } else if (opt->arg == 2) {
+ docallback(opt->optval, NULL);
+ continue;
+ } else {
+ argstring[1] = *p;
+ docallback(':', argstring);
+ break;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+/* Verify that str points to an ASCII zero or one (optionally with
+ * whitespace) and return the value present, or -1 if str's contents
+ * are anything else.
+ */
+static int readboolvalue(char const *str)
+{
+ char d;
+
+ while (isspace(*str))
+ ++str;
+ if (!*str)
+ return -1;
+ d = *str++;
+ while (isspace(*str))
+ ++str;
+ if (*str)
+ return -1;
+ if (d == '0')
+ return 0;
+ else if (d == '1')
+ return 1;
+ else
+ return -1;
+}
+
+/* Parse a configuration file.
+ */
+int readcfgfile(option const* list, FILE *fp,
+ int (*callback)(int, char const*, void*), void *data)
+{
+ char buf[1024];
+ option const *opt;
+ char *name, *val, *p;
+ int len, f, r;
+
+ while (fgets(buf, sizeof buf, fp) != NULL)
+ {
+ /* Strip off the trailing newline and any leading whitespace.
+ * If the line begins with a hash sign, skip it entirely.
+ */
+ len = strlen(buf);
+ if (len && buf[len - 1] == '\n')
+ buf[--len] = '\0';
+ for (p = buf ; isspace(*p) ; ++p) ;
+ if (!*p || *p == '#')
+ continue;
+
+ /* Find the end of the option's name and the beginning of the
+ * parameter, if any.
+ */
+ for (name = p ; *p && *p != '=' && !isspace(*p) ; ++p) ;
+ len = p - name;
+ for ( ; *p == '=' || isspace(*p) ; ++p) ;
+ val = p;
+
+ /* Is it on the list of valid options? Does it take a
+ * full parameter, or just an optional boolean?
+ */
+ for (opt = list ; opt->optval ; ++opt)
+ if (opt->name && !strncmp(name, opt->name, len)
+ && !opt->name[len])
+ break;
+ if (!opt->optval) {
+ docallback('?', name);
+ } else if (!*val && opt->arg == 1) {
+ docallback(':', name);
+ } else if (*val && opt->arg == 0) {
+ f = readboolvalue(val);
+ if (f < 0)
+ docallback('=', name);
+ else if (f == 1)
+ docallback(opt->optval, NULL);
+ } else {
+ docallback(opt->optval, val);
+ }
+ }
+ return ferror(fp) ? -1 : 0;
+}
+
+/* Turn a string containing a cmdline into an argc-argv pair.
+ */
+int makecmdline(char const *cmdline, int *argcp, char ***argvp)
+{
+ char **argv;
+ int argc;
+ char const *s;
+ int n, quoted;
+
+ if (!cmdline)
+ return 0;
+
+ /* Calcuate argc by counting the number of "clumps" of non-spaces.
+ */
+ for (s = cmdline ; isspace(*s) ; ++s) ;
+ if (!*s) {
+ *argcp = 1;
+ if (argvp) {
+ *argvp = malloc(2 * sizeof(char*));
+ if (!*argvp)
+ return 0;
+ (*argvp)[0] = NULL;
+ (*argvp)[1] = NULL;
+ }
+ return 1;
+ }
+ for (argc = 2, quoted = 0 ; *s ; ++s) {
+ if (quoted == '"') {
+ if (*s == '"')
+ quoted = 0;
+ else if (*s == '\\' && s[1])
+ ++s;
+ } else if (quoted == '\'') {
+ if (*s == '\'')
+ quoted = 0;
+ } else {
+ if (isspace(*s)) {
+ for ( ; isspace(s[1]) ; ++s) ;
+ if (!s[1])
+ break;
+ ++argc;
+ } else if (*s == '"' || *s == '\'') {
+ quoted = *s;
+ }
+ }
+ }
+
+ *argcp = argc;
+ if (!argvp)
+ return 1;
+
+ /* Allocate space for all the arguments and their pointers.
+ */
+ argv = malloc((argc + 1) * sizeof(char*) + strlen(cmdline) + 1);
+ *argvp = argv;
+ if (!argv)
+ return 0;
+ argv[0] = NULL;
+ argv[1] = (char*)(argv + argc + 1);
+
+ /* Copy the string into the allocated memory immediately after the
+ * argv array. Where spaces immediately follows a nonspace,
+ * replace it with a \0. Where a nonspace immediately follows
+ * spaces, store a pointer to it. (Except, of course, when the
+ * space-nonspace transitions occur within quotes.)
+ */
+ for (s = cmdline ; isspace(*s) ; ++s) ;
+ for (argc = 1, n = 0, quoted = 0 ; *s ; ++s) {
+ if (quoted == '"') {
+ if (*s == '"') {
+ quoted = 0;
+ } else {
+ if (*s == '\\' && s[1])
+ ++s;
+ argv[argc][n++] = *s;
+ }
+ } else if (quoted == '\'') {
+ if (*s == '\'')
+ quoted = 0;
+ else
+ argv[argc][n++] = *s;
+ } else {
+ if (isspace(*s)) {
+ argv[argc][n] = '\0';
+ for ( ; isspace(s[1]) ; ++s) ;
+ if (!s[1])
+ break;
+ argv[argc + 1] = argv[argc] + n + 1;
+ ++argc;
+ n = 0;
+ } else {
+ if (*s == '"' || *s == '\'')
+ quoted = *s;
+ else
+ argv[argc][n++] = *s;
+ }
+ }
+ }
+ argv[argc + 1] = NULL;
+ return 1;
+}
diff --git a/cmdline.h b/cmdline.h
@@ -0,0 +1,86 @@
+/* cmdline.h: a reentrant version of getopt(). Written 2006 by Brian
+ * Raiter. This code is in the public domain.
+ */
+
+#ifndef _cmdline_h_
+#define _cmdline_h_
+
+/* The information specifying a single cmdline option.
+ */
+typedef struct option {
+ char const *name; /* the option's long name, or "" if none */
+ char chname; /* a single-char name, or zero if none */
+ int optval; /* a unique value representing this option */
+ int arg; /* 0 = no arg, 1 = arg req'd, 2 = optional */
+} option;
+
+/* Parse the given cmdline arguments. list is an array of option
+ * structs, each entry specifying a valid option. The last struct in
+ * the array must have name set to NULL. argc and argv give the
+ * cmdline to parse. callback is the function to call for each option
+ * and non-option found on the cmdline. data is a pointer that is
+ * passed to each invocation of callback. The return value of callback
+ * should be zero to continue processing the cmdline, or any other
+ * value to abort. The return value of readoptions() is the value
+ * returned from the last callback, or zero if no arguments were
+ * found, or -1 if an error occurred.
+ *
+ * When readoptions() encounters a regular cmdline argument (i.e. a
+ * non-option argument), callback() is invoked with opt equal to zero
+ * and val pointing to the argument. When an option is found,
+ * callback() is invoked with opt equal to the optval field in the
+ * option struct corresponding to that option, and val points to the
+ * option's paramter, or is NULL if the option does not take a
+ * parameter. If readoptions() finds an option that does not appear in
+ * the list of valid options, callback() is invoked with opt equal to
+ * '?'. If readoptions() encounters an option that is missing its
+ * required parameter, callback() is invoked with opt equal to ':'. If
+ * readoptions() finds a parameter on a long option that does not
+ * admit a parameter, callback() is invoked with opt equal to '='. In
+ * each of these cases, val will point to the erroneous option
+ * argument.
+ */
+extern int readoptions(option const* list, int argc, char **argv,
+ int (*callback)(int opt, char const *val, void *data),
+ void *data);
+
+/* Parse the given file. list is an array of option structs, in the
+ * same form as taken by readoptions(). fp is a pointer to an open
+ * text file. callback is the function to call for each line found in
+ * the configuration file. data is a pointer that is passed to each
+ * invocation of callback. The return value of readcfgfile() is the
+ * value returned from the last callback, or zero if no arguments were
+ * found, or -1 if an error occurred while reading the file.
+ *
+ * The function will ignore lines that contain only whitespace, or
+ * lines that begin with a hash sign. All other lines should be of the
+ * form "OPTION=VALUE", where OPTION is one of the long options in
+ * list. Whitespace around the equal sign is permitted. An option that
+ * takes no arguments can either have a VALUE of 0 or 1, or omit the
+ * "=VALUE" entirely. (A VALUE of 0 will behave the same as if the
+ * line was not present.)
+ */
+extern int readcfgfile(option const* list, FILE *fp,
+ int (*callback)(int opt, char const *val, void *data),
+ void *data);
+
+
+/* Create an argc-argv pair from a string containing a command line.
+ * cmdline is the string to be parsed. argcp points to the variable to
+ * receive the argc value, and argvp points to the variable to receive
+ * the argv value. argvp can be NULL if the caller just wants to get
+ * argc. Zero is returned on failure. This function allocates memory
+ * on behalf of the caller. The memory is allocated as a single block,
+ * so it is sufficient to simply free() the pointer returned through
+ * argvp. Note that argv[0] will always be initialized to NULL; the
+ * first argument will be stored in argv[1]. The string is parsed by
+ * separating arguments on whitespace boundaries. Space within
+ * substrings enclosed in single-quotes is ignored. A substring
+ * enclosed in double-quotes is treated the same, except that the
+ * backslash is recognized as an escape character within such a
+ * substring. Enclosing quotes and escaping backslashes are not copied
+ * into the argv values.
+ */
+extern int makecmdline(char const *cmdline, int *argcp, char ***argvp);
+
+#endif
diff --git a/entity.c b/entity.c
@@ -0,0 +1,2190 @@
+/*
+ * MD4C: Markdown parser for C
+ * (http://github.com/mity/md4c)
+ *
+ * Copyright (c) 2016-2017 Martin Mitas
+ *
+ * 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.
+ */
+
+#include "entity.h"
+#include <string.h>
+
+
+/* The table is generated from https://html.spec.whatwg.org/entities.json */
+static const struct entity entity_table[] = {
+ { "Æ", { 198, 0 } },
+ { "&", { 38, 0 } },
+ { "Á", { 193, 0 } },
+ { "Ă", { 258, 0 } },
+ { "Â", { 194, 0 } },
+ { "А", { 1040, 0 } },
+ { "𝔄", { 120068, 0 } },
+ { "À", { 192, 0 } },
+ { "Α", { 913, 0 } },
+ { "Ā", { 256, 0 } },
+ { "⩓", { 10835, 0 } },
+ { "Ą", { 260, 0 } },
+ { "𝔸", { 120120, 0 } },
+ { "⁡", { 8289, 0 } },
+ { "Å", { 197, 0 } },
+ { "𝒜", { 119964, 0 } },
+ { "≔", { 8788, 0 } },
+ { "Ã", { 195, 0 } },
+ { "Ä", { 196, 0 } },
+ { "∖", { 8726, 0 } },
+ { "⫧", { 10983, 0 } },
+ { "⌆", { 8966, 0 } },
+ { "Б", { 1041, 0 } },
+ { "∵", { 8757, 0 } },
+ { "ℬ", { 8492, 0 } },
+ { "Β", { 914, 0 } },
+ { "𝔅", { 120069, 0 } },
+ { "𝔹", { 120121, 0 } },
+ { "˘", { 728, 0 } },
+ { "ℬ", { 8492, 0 } },
+ { "≎", { 8782, 0 } },
+ { "Ч", { 1063, 0 } },
+ { "©", { 169, 0 } },
+ { "Ć", { 262, 0 } },
+ { "⋒", { 8914, 0 } },
+ { "ⅅ", { 8517, 0 } },
+ { "ℭ", { 8493, 0 } },
+ { "Č", { 268, 0 } },
+ { "Ç", { 199, 0 } },
+ { "Ĉ", { 264, 0 } },
+ { "∰", { 8752, 0 } },
+ { "Ċ", { 266, 0 } },
+ { "¸", { 184, 0 } },
+ { "·", { 183, 0 } },
+ { "ℭ", { 8493, 0 } },
+ { "Χ", { 935, 0 } },
+ { "⊙", { 8857, 0 } },
+ { "⊖", { 8854, 0 } },
+ { "⊕", { 8853, 0 } },
+ { "⊗", { 8855, 0 } },
+ { "∲", { 8754, 0 } },
+ { "”", { 8221, 0 } },
+ { "’", { 8217, 0 } },
+ { "∷", { 8759, 0 } },
+ { "⩴", { 10868, 0 } },
+ { "≡", { 8801, 0 } },
+ { "∯", { 8751, 0 } },
+ { "∮", { 8750, 0 } },
+ { "ℂ", { 8450, 0 } },
+ { "∐", { 8720, 0 } },
+ { "∳", { 8755, 0 } },
+ { "⨯", { 10799, 0 } },
+ { "𝒞", { 119966, 0 } },
+ { "⋓", { 8915, 0 } },
+ { "≍", { 8781, 0 } },
+ { "ⅅ", { 8517, 0 } },
+ { "⤑", { 10513, 0 } },
+ { "Ђ", { 1026, 0 } },
+ { "Ѕ", { 1029, 0 } },
+ { "Џ", { 1039, 0 } },
+ { "‡", { 8225, 0 } },
+ { "↡", { 8609, 0 } },
+ { "⫤", { 10980, 0 } },
+ { "Ď", { 270, 0 } },
+ { "Д", { 1044, 0 } },
+ { "∇", { 8711, 0 } },
+ { "Δ", { 916, 0 } },
+ { "𝔇", { 120071, 0 } },
+ { "´", { 180, 0 } },
+ { "˙", { 729, 0 } },
+ { "˝", { 733, 0 } },
+ { "`", { 96, 0 } },
+ { "˜", { 732, 0 } },
+ { "⋄", { 8900, 0 } },
+ { "ⅆ", { 8518, 0 } },
+ { "𝔻", { 120123, 0 } },
+ { "¨", { 168, 0 } },
+ { "⃜", { 8412, 0 } },
+ { "≐", { 8784, 0 } },
+ { "∯", { 8751, 0 } },
+ { "¨", { 168, 0 } },
+ { "⇓", { 8659, 0 } },
+ { "⇐", { 8656, 0 } },
+ { "⇔", { 8660, 0 } },
+ { "⫤", { 10980, 0 } },
+ { "⟸", { 10232, 0 } },
+ { "⟺", { 10234, 0 } },
+ { "⟹", { 10233, 0 } },
+ { "⇒", { 8658, 0 } },
+ { "⊨", { 8872, 0 } },
+ { "⇑", { 8657, 0 } },
+ { "⇕", { 8661, 0 } },
+ { "∥", { 8741, 0 } },
+ { "↓", { 8595, 0 } },
+ { "⤓", { 10515, 0 } },
+ { "⇵", { 8693, 0 } },
+ { "̑", { 785, 0 } },
+ { "⥐", { 10576, 0 } },
+ { "⥞", { 10590, 0 } },
+ { "↽", { 8637, 0 } },
+ { "⥖", { 10582, 0 } },
+ { "⥟", { 10591, 0 } },
+ { "⇁", { 8641, 0 } },
+ { "⥗", { 10583, 0 } },
+ { "⊤", { 8868, 0 } },
+ { "↧", { 8615, 0 } },
+ { "⇓", { 8659, 0 } },
+ { "𝒟", { 119967, 0 } },
+ { "Đ", { 272, 0 } },
+ { "Ŋ", { 330, 0 } },
+ { "Ð", { 208, 0 } },
+ { "É", { 201, 0 } },
+ { "Ě", { 282, 0 } },
+ { "Ê", { 202, 0 } },
+ { "Э", { 1069, 0 } },
+ { "Ė", { 278, 0 } },
+ { "𝔈", { 120072, 0 } },
+ { "È", { 200, 0 } },
+ { "∈", { 8712, 0 } },
+ { "Ē", { 274, 0 } },
+ { "◻", { 9723, 0 } },
+ { "▫", { 9643, 0 } },
+ { "Ę", { 280, 0 } },
+ { "𝔼", { 120124, 0 } },
+ { "Ε", { 917, 0 } },
+ { "⩵", { 10869, 0 } },
+ { "≂", { 8770, 0 } },
+ { "⇌", { 8652, 0 } },
+ { "ℰ", { 8496, 0 } },
+ { "⩳", { 10867, 0 } },
+ { "Η", { 919, 0 } },
+ { "Ë", { 203, 0 } },
+ { "∃", { 8707, 0 } },
+ { "ⅇ", { 8519, 0 } },
+ { "Ф", { 1060, 0 } },
+ { "𝔉", { 120073, 0 } },
+ { "◼", { 9724, 0 } },
+ { "▪", { 9642, 0 } },
+ { "𝔽", { 120125, 0 } },
+ { "∀", { 8704, 0 } },
+ { "ℱ", { 8497, 0 } },
+ { "ℱ", { 8497, 0 } },
+ { "Ѓ", { 1027, 0 } },
+ { ">", { 62, 0 } },
+ { "Γ", { 915, 0 } },
+ { "Ϝ", { 988, 0 } },
+ { "Ğ", { 286, 0 } },
+ { "Ģ", { 290, 0 } },
+ { "Ĝ", { 284, 0 } },
+ { "Г", { 1043, 0 } },
+ { "Ġ", { 288, 0 } },
+ { "𝔊", { 120074, 0 } },
+ { "⋙", { 8921, 0 } },
+ { "𝔾", { 120126, 0 } },
+ { "≥", { 8805, 0 } },
+ { "⋛", { 8923, 0 } },
+ { "≧", { 8807, 0 } },
+ { "⪢", { 10914, 0 } },
+ { "≷", { 8823, 0 } },
+ { "⩾", { 10878, 0 } },
+ { "≳", { 8819, 0 } },
+ { "𝒢", { 119970, 0 } },
+ { "≫", { 8811, 0 } },
+ { "Ъ", { 1066, 0 } },
+ { "ˇ", { 711, 0 } },
+ { "^", { 94, 0 } },
+ { "Ĥ", { 292, 0 } },
+ { "ℌ", { 8460, 0 } },
+ { "ℋ", { 8459, 0 } },
+ { "ℍ", { 8461, 0 } },
+ { "─", { 9472, 0 } },
+ { "ℋ", { 8459, 0 } },
+ { "Ħ", { 294, 0 } },
+ { "≎", { 8782, 0 } },
+ { "≏", { 8783, 0 } },
+ { "Е", { 1045, 0 } },
+ { "IJ", { 306, 0 } },
+ { "Ё", { 1025, 0 } },
+ { "Í", { 205, 0 } },
+ { "Î", { 206, 0 } },
+ { "И", { 1048, 0 } },
+ { "İ", { 304, 0 } },
+ { "ℑ", { 8465, 0 } },
+ { "Ì", { 204, 0 } },
+ { "ℑ", { 8465, 0 } },
+ { "Ī", { 298, 0 } },
+ { "ⅈ", { 8520, 0 } },
+ { "⇒", { 8658, 0 } },
+ { "∬", { 8748, 0 } },
+ { "∫", { 8747, 0 } },
+ { "⋂", { 8898, 0 } },
+ { "⁣", { 8291, 0 } },
+ { "⁢", { 8290, 0 } },
+ { "Į", { 302, 0 } },
+ { "𝕀", { 120128, 0 } },
+ { "Ι", { 921, 0 } },
+ { "ℐ", { 8464, 0 } },
+ { "Ĩ", { 296, 0 } },
+ { "І", { 1030, 0 } },
+ { "Ï", { 207, 0 } },
+ { "Ĵ", { 308, 0 } },
+ { "Й", { 1049, 0 } },
+ { "𝔍", { 120077, 0 } },
+ { "𝕁", { 120129, 0 } },
+ { "𝒥", { 119973, 0 } },
+ { "Ј", { 1032, 0 } },
+ { "Є", { 1028, 0 } },
+ { "Х", { 1061, 0 } },
+ { "Ќ", { 1036, 0 } },
+ { "Κ", { 922, 0 } },
+ { "Ķ", { 310, 0 } },
+ { "К", { 1050, 0 } },
+ { "𝔎", { 120078, 0 } },
+ { "𝕂", { 120130, 0 } },
+ { "𝒦", { 119974, 0 } },
+ { "Љ", { 1033, 0 } },
+ { "<", { 60, 0 } },
+ { "Ĺ", { 313, 0 } },
+ { "Λ", { 923, 0 } },
+ { "⟪", { 10218, 0 } },
+ { "ℒ", { 8466, 0 } },
+ { "↞", { 8606, 0 } },
+ { "Ľ", { 317, 0 } },
+ { "Ļ", { 315, 0 } },
+ { "Л", { 1051, 0 } },
+ { "⟨", { 10216, 0 } },
+ { "←", { 8592, 0 } },
+ { "⇤", { 8676, 0 } },
+ { "⇆", { 8646, 0 } },
+ { "⌈", { 8968, 0 } },
+ { "⟦", { 10214, 0 } },
+ { "⥡", { 10593, 0 } },
+ { "⇃", { 8643, 0 } },
+ { "⥙", { 10585, 0 } },
+ { "⌊", { 8970, 0 } },
+ { "↔", { 8596, 0 } },
+ { "⥎", { 10574, 0 } },
+ { "⊣", { 8867, 0 } },
+ { "↤", { 8612, 0 } },
+ { "⥚", { 10586, 0 } },
+ { "⊲", { 8882, 0 } },
+ { "⧏", { 10703, 0 } },
+ { "⊴", { 8884, 0 } },
+ { "⥑", { 10577, 0 } },
+ { "⥠", { 10592, 0 } },
+ { "↿", { 8639, 0 } },
+ { "⥘", { 10584, 0 } },
+ { "↼", { 8636, 0 } },
+ { "⥒", { 10578, 0 } },
+ { "⇐", { 8656, 0 } },
+ { "⇔", { 8660, 0 } },
+ { "⋚", { 8922, 0 } },
+ { "≦", { 8806, 0 } },
+ { "≶", { 8822, 0 } },
+ { "⪡", { 10913, 0 } },
+ { "⩽", { 10877, 0 } },
+ { "≲", { 8818, 0 } },
+ { "𝔏", { 120079, 0 } },
+ { "⋘", { 8920, 0 } },
+ { "⇚", { 8666, 0 } },
+ { "Ŀ", { 319, 0 } },
+ { "⟵", { 10229, 0 } },
+ { "⟷", { 10231, 0 } },
+ { "⟶", { 10230, 0 } },
+ { "⟸", { 10232, 0 } },
+ { "⟺", { 10234, 0 } },
+ { "⟹", { 10233, 0 } },
+ { "𝕃", { 120131, 0 } },
+ { "↙", { 8601, 0 } },
+ { "↘", { 8600, 0 } },
+ { "ℒ", { 8466, 0 } },
+ { "↰", { 8624, 0 } },
+ { "Ł", { 321, 0 } },
+ { "≪", { 8810, 0 } },
+ { "⤅", { 10501, 0 } },
+ { "М", { 1052, 0 } },
+ { " ", { 8287, 0 } },
+ { "ℳ", { 8499, 0 } },
+ { "𝔐", { 120080, 0 } },
+ { "∓", { 8723, 0 } },
+ { "𝕄", { 120132, 0 } },
+ { "ℳ", { 8499, 0 } },
+ { "Μ", { 924, 0 } },
+ { "Њ", { 1034, 0 } },
+ { "Ń", { 323, 0 } },
+ { "Ň", { 327, 0 } },
+ { "Ņ", { 325, 0 } },
+ { "Н", { 1053, 0 } },
+ { "​", { 8203, 0 } },
+ { "​", { 8203, 0 } },
+ { "​", { 8203, 0 } },
+ { "​", { 8203, 0 } },
+ { "≫", { 8811, 0 } },
+ { "≪", { 8810, 0 } },
+ { "
", { 10, 0 } },
+ { "𝔑", { 120081, 0 } },
+ { "⁠", { 8288, 0 } },
+ { " ", { 160, 0 } },
+ { "ℕ", { 8469, 0 } },
+ { "⫬", { 10988, 0 } },
+ { "≢", { 8802, 0 } },
+ { "≭", { 8813, 0 } },
+ { "∦", { 8742, 0 } },
+ { "∉", { 8713, 0 } },
+ { "≠", { 8800, 0 } },
+ { "≂̸", { 8770, 824 } },
+ { "∄", { 8708, 0 } },
+ { "≯", { 8815, 0 } },
+ { "≱", { 8817, 0 } },
+ { "≧̸", { 8807, 824 } },
+ { "≫̸", { 8811, 824 } },
+ { "≹", { 8825, 0 } },
+ { "⩾̸", { 10878, 824 } },
+ { "≵", { 8821, 0 } },
+ { "≎̸", { 8782, 824 } },
+ { "≏̸", { 8783, 824 } },
+ { "⋪", { 8938, 0 } },
+ { "⧏̸", { 10703, 824 } },
+ { "⋬", { 8940, 0 } },
+ { "≮", { 8814, 0 } },
+ { "≰", { 8816, 0 } },
+ { "≸", { 8824, 0 } },
+ { "≪̸", { 8810, 824 } },
+ { "⩽̸", { 10877, 824 } },
+ { "≴", { 8820, 0 } },
+ { "⪢̸", { 10914, 824 } },
+ { "⪡̸", { 10913, 824 } },
+ { "⊀", { 8832, 0 } },
+ { "⪯̸", { 10927, 824 } },
+ { "⋠", { 8928, 0 } },
+ { "∌", { 8716, 0 } },
+ { "⋫", { 8939, 0 } },
+ { "⧐̸", { 10704, 824 } },
+ { "⋭", { 8941, 0 } },
+ { "⊏̸", { 8847, 824 } },
+ { "⋢", { 8930, 0 } },
+ { "⊐̸", { 8848, 824 } },
+ { "⋣", { 8931, 0 } },
+ { "⊂⃒", { 8834, 8402 } },
+ { "⊈", { 8840, 0 } },
+ { "⊁", { 8833, 0 } },
+ { "⪰̸", { 10928, 824 } },
+ { "⋡", { 8929, 0 } },
+ { "≿̸", { 8831, 824 } },
+ { "⊃⃒", { 8835, 8402 } },
+ { "⊉", { 8841, 0 } },
+ { "≁", { 8769, 0 } },
+ { "≄", { 8772, 0 } },
+ { "≇", { 8775, 0 } },
+ { "≉", { 8777, 0 } },
+ { "∤", { 8740, 0 } },
+ { "𝒩", { 119977, 0 } },
+ { "Ñ", { 209, 0 } },
+ { "Ν", { 925, 0 } },
+ { "Œ", { 338, 0 } },
+ { "Ó", { 211, 0 } },
+ { "Ô", { 212, 0 } },
+ { "О", { 1054, 0 } },
+ { "Ő", { 336, 0 } },
+ { "𝔒", { 120082, 0 } },
+ { "Ò", { 210, 0 } },
+ { "Ō", { 332, 0 } },
+ { "Ω", { 937, 0 } },
+ { "Ο", { 927, 0 } },
+ { "𝕆", { 120134, 0 } },
+ { "“", { 8220, 0 } },
+ { "‘", { 8216, 0 } },
+ { "⩔", { 10836, 0 } },
+ { "𝒪", { 119978, 0 } },
+ { "Ø", { 216, 0 } },
+ { "Õ", { 213, 0 } },
+ { "⨷", { 10807, 0 } },
+ { "Ö", { 214, 0 } },
+ { "‾", { 8254, 0 } },
+ { "⏞", { 9182, 0 } },
+ { "⎴", { 9140, 0 } },
+ { "⏜", { 9180, 0 } },
+ { "∂", { 8706, 0 } },
+ { "П", { 1055, 0 } },
+ { "𝔓", { 120083, 0 } },
+ { "Φ", { 934, 0 } },
+ { "Π", { 928, 0 } },
+ { "±", { 177, 0 } },
+ { "ℌ", { 8460, 0 } },
+ { "ℙ", { 8473, 0 } },
+ { "⪻", { 10939, 0 } },
+ { "≺", { 8826, 0 } },
+ { "⪯", { 10927, 0 } },
+ { "≼", { 8828, 0 } },
+ { "≾", { 8830, 0 } },
+ { "″", { 8243, 0 } },
+ { "∏", { 8719, 0 } },
+ { "∷", { 8759, 0 } },
+ { "∝", { 8733, 0 } },
+ { "𝒫", { 119979, 0 } },
+ { "Ψ", { 936, 0 } },
+ { """, { 34, 0 } },
+ { "𝔔", { 120084, 0 } },
+ { "ℚ", { 8474, 0 } },
+ { "𝒬", { 119980, 0 } },
+ { "⤐", { 10512, 0 } },
+ { "®", { 174, 0 } },
+ { "Ŕ", { 340, 0 } },
+ { "⟫", { 10219, 0 } },
+ { "↠", { 8608, 0 } },
+ { "⤖", { 10518, 0 } },
+ { "Ř", { 344, 0 } },
+ { "Ŗ", { 342, 0 } },
+ { "Р", { 1056, 0 } },
+ { "ℜ", { 8476, 0 } },
+ { "∋", { 8715, 0 } },
+ { "⇋", { 8651, 0 } },
+ { "⥯", { 10607, 0 } },
+ { "ℜ", { 8476, 0 } },
+ { "Ρ", { 929, 0 } },
+ { "⟩", { 10217, 0 } },
+ { "→", { 8594, 0 } },
+ { "⇥", { 8677, 0 } },
+ { "⇄", { 8644, 0 } },
+ { "⌉", { 8969, 0 } },
+ { "⟧", { 10215, 0 } },
+ { "⥝", { 10589, 0 } },
+ { "⇂", { 8642, 0 } },
+ { "⥕", { 10581, 0 } },
+ { "⌋", { 8971, 0 } },
+ { "⊢", { 8866, 0 } },
+ { "↦", { 8614, 0 } },
+ { "⥛", { 10587, 0 } },
+ { "⊳", { 8883, 0 } },
+ { "⧐", { 10704, 0 } },
+ { "⊵", { 8885, 0 } },
+ { "⥏", { 10575, 0 } },
+ { "⥜", { 10588, 0 } },
+ { "↾", { 8638, 0 } },
+ { "⥔", { 10580, 0 } },
+ { "⇀", { 8640, 0 } },
+ { "⥓", { 10579, 0 } },
+ { "⇒", { 8658, 0 } },
+ { "ℝ", { 8477, 0 } },
+ { "⥰", { 10608, 0 } },
+ { "⇛", { 8667, 0 } },
+ { "ℛ", { 8475, 0 } },
+ { "↱", { 8625, 0 } },
+ { "⧴", { 10740, 0 } },
+ { "Щ", { 1065, 0 } },
+ { "Ш", { 1064, 0 } },
+ { "Ь", { 1068, 0 } },
+ { "Ś", { 346, 0 } },
+ { "⪼", { 10940, 0 } },
+ { "Š", { 352, 0 } },
+ { "Ş", { 350, 0 } },
+ { "Ŝ", { 348, 0 } },
+ { "С", { 1057, 0 } },
+ { "𝔖", { 120086, 0 } },
+ { "↓", { 8595, 0 } },
+ { "←", { 8592, 0 } },
+ { "→", { 8594, 0 } },
+ { "↑", { 8593, 0 } },
+ { "Σ", { 931, 0 } },
+ { "∘", { 8728, 0 } },
+ { "𝕊", { 120138, 0 } },
+ { "√", { 8730, 0 } },
+ { "□", { 9633, 0 } },
+ { "⊓", { 8851, 0 } },
+ { "⊏", { 8847, 0 } },
+ { "⊑", { 8849, 0 } },
+ { "⊐", { 8848, 0 } },
+ { "⊒", { 8850, 0 } },
+ { "⊔", { 8852, 0 } },
+ { "𝒮", { 119982, 0 } },
+ { "⋆", { 8902, 0 } },
+ { "⋐", { 8912, 0 } },
+ { "⋐", { 8912, 0 } },
+ { "⊆", { 8838, 0 } },
+ { "≻", { 8827, 0 } },
+ { "⪰", { 10928, 0 } },
+ { "≽", { 8829, 0 } },
+ { "≿", { 8831, 0 } },
+ { "∋", { 8715, 0 } },
+ { "∑", { 8721, 0 } },
+ { "⋑", { 8913, 0 } },
+ { "⊃", { 8835, 0 } },
+ { "⊇", { 8839, 0 } },
+ { "⋑", { 8913, 0 } },
+ { "Þ", { 222, 0 } },
+ { "™", { 8482, 0 } },
+ { "Ћ", { 1035, 0 } },
+ { "Ц", { 1062, 0 } },
+ { "	", { 9, 0 } },
+ { "Τ", { 932, 0 } },
+ { "Ť", { 356, 0 } },
+ { "Ţ", { 354, 0 } },
+ { "Т", { 1058, 0 } },
+ { "𝔗", { 120087, 0 } },
+ { "∴", { 8756, 0 } },
+ { "Θ", { 920, 0 } },
+ { "  ", { 8287, 8202 } },
+ { " ", { 8201, 0 } },
+ { "∼", { 8764, 0 } },
+ { "≃", { 8771, 0 } },
+ { "≅", { 8773, 0 } },
+ { "≈", { 8776, 0 } },
+ { "𝕋", { 120139, 0 } },
+ { "⃛", { 8411, 0 } },
+ { "𝒯", { 119983, 0 } },
+ { "Ŧ", { 358, 0 } },
+ { "Ú", { 218, 0 } },
+ { "↟", { 8607, 0 } },
+ { "⥉", { 10569, 0 } },
+ { "Ў", { 1038, 0 } },
+ { "Ŭ", { 364, 0 } },
+ { "Û", { 219, 0 } },
+ { "У", { 1059, 0 } },
+ { "Ű", { 368, 0 } },
+ { "𝔘", { 120088, 0 } },
+ { "Ù", { 217, 0 } },
+ { "Ū", { 362, 0 } },
+ { "_", { 95, 0 } },
+ { "⏟", { 9183, 0 } },
+ { "⎵", { 9141, 0 } },
+ { "⏝", { 9181, 0 } },
+ { "⋃", { 8899, 0 } },
+ { "⊎", { 8846, 0 } },
+ { "Ų", { 370, 0 } },
+ { "𝕌", { 120140, 0 } },
+ { "↑", { 8593, 0 } },
+ { "⤒", { 10514, 0 } },
+ { "⇅", { 8645, 0 } },
+ { "↕", { 8597, 0 } },
+ { "⥮", { 10606, 0 } },
+ { "⊥", { 8869, 0 } },
+ { "↥", { 8613, 0 } },
+ { "⇑", { 8657, 0 } },
+ { "⇕", { 8661, 0 } },
+ { "↖", { 8598, 0 } },
+ { "↗", { 8599, 0 } },
+ { "ϒ", { 978, 0 } },
+ { "Υ", { 933, 0 } },
+ { "Ů", { 366, 0 } },
+ { "𝒰", { 119984, 0 } },
+ { "Ũ", { 360, 0 } },
+ { "Ü", { 220, 0 } },
+ { "⊫", { 8875, 0 } },
+ { "⫫", { 10987, 0 } },
+ { "В", { 1042, 0 } },
+ { "⊩", { 8873, 0 } },
+ { "⫦", { 10982, 0 } },
+ { "⋁", { 8897, 0 } },
+ { "‖", { 8214, 0 } },
+ { "‖", { 8214, 0 } },
+ { "∣", { 8739, 0 } },
+ { "|", { 124, 0 } },
+ { "❘", { 10072, 0 } },
+ { "≀", { 8768, 0 } },
+ { " ", { 8202, 0 } },
+ { "𝔙", { 120089, 0 } },
+ { "𝕍", { 120141, 0 } },
+ { "𝒱", { 119985, 0 } },
+ { "⊪", { 8874, 0 } },
+ { "Ŵ", { 372, 0 } },
+ { "⋀", { 8896, 0 } },
+ { "𝔚", { 120090, 0 } },
+ { "𝕎", { 120142, 0 } },
+ { "𝒲", { 119986, 0 } },
+ { "𝔛", { 120091, 0 } },
+ { "Ξ", { 926, 0 } },
+ { "𝕏", { 120143, 0 } },
+ { "𝒳", { 119987, 0 } },
+ { "Я", { 1071, 0 } },
+ { "Ї", { 1031, 0 } },
+ { "Ю", { 1070, 0 } },
+ { "Ý", { 221, 0 } },
+ { "Ŷ", { 374, 0 } },
+ { "Ы", { 1067, 0 } },
+ { "𝔜", { 120092, 0 } },
+ { "𝕐", { 120144, 0 } },
+ { "𝒴", { 119988, 0 } },
+ { "Ÿ", { 376, 0 } },
+ { "Ж", { 1046, 0 } },
+ { "Ź", { 377, 0 } },
+ { "Ž", { 381, 0 } },
+ { "З", { 1047, 0 } },
+ { "Ż", { 379, 0 } },
+ { "​", { 8203, 0 } },
+ { "Ζ", { 918, 0 } },
+ { "ℨ", { 8488, 0 } },
+ { "ℤ", { 8484, 0 } },
+ { "𝒵", { 119989, 0 } },
+ { "á", { 225, 0 } },
+ { "ă", { 259, 0 } },
+ { "∾", { 8766, 0 } },
+ { "∾̳", { 8766, 819 } },
+ { "∿", { 8767, 0 } },
+ { "â", { 226, 0 } },
+ { "´", { 180, 0 } },
+ { "а", { 1072, 0 } },
+ { "æ", { 230, 0 } },
+ { "⁡", { 8289, 0 } },
+ { "𝔞", { 120094, 0 } },
+ { "à", { 224, 0 } },
+ { "ℵ", { 8501, 0 } },
+ { "ℵ", { 8501, 0 } },
+ { "α", { 945, 0 } },
+ { "ā", { 257, 0 } },
+ { "⨿", { 10815, 0 } },
+ { "&", { 38, 0 } },
+ { "∧", { 8743, 0 } },
+ { "⩕", { 10837, 0 } },
+ { "⩜", { 10844, 0 } },
+ { "⩘", { 10840, 0 } },
+ { "⩚", { 10842, 0 } },
+ { "∠", { 8736, 0 } },
+ { "⦤", { 10660, 0 } },
+ { "∠", { 8736, 0 } },
+ { "∡", { 8737, 0 } },
+ { "⦨", { 10664, 0 } },
+ { "⦩", { 10665, 0 } },
+ { "⦪", { 10666, 0 } },
+ { "⦫", { 10667, 0 } },
+ { "⦬", { 10668, 0 } },
+ { "⦭", { 10669, 0 } },
+ { "⦮", { 10670, 0 } },
+ { "⦯", { 10671, 0 } },
+ { "∟", { 8735, 0 } },
+ { "⊾", { 8894, 0 } },
+ { "⦝", { 10653, 0 } },
+ { "∢", { 8738, 0 } },
+ { "Å", { 197, 0 } },
+ { "⍼", { 9084, 0 } },
+ { "ą", { 261, 0 } },
+ { "𝕒", { 120146, 0 } },
+ { "≈", { 8776, 0 } },
+ { "⩰", { 10864, 0 } },
+ { "⩯", { 10863, 0 } },
+ { "≊", { 8778, 0 } },
+ { "≋", { 8779, 0 } },
+ { "'", { 39, 0 } },
+ { "≈", { 8776, 0 } },
+ { "≊", { 8778, 0 } },
+ { "å", { 229, 0 } },
+ { "𝒶", { 119990, 0 } },
+ { "*", { 42, 0 } },
+ { "≈", { 8776, 0 } },
+ { "≍", { 8781, 0 } },
+ { "ã", { 227, 0 } },
+ { "ä", { 228, 0 } },
+ { "∳", { 8755, 0 } },
+ { "⨑", { 10769, 0 } },
+ { "⫭", { 10989, 0 } },
+ { "≌", { 8780, 0 } },
+ { "϶", { 1014, 0 } },
+ { "‵", { 8245, 0 } },
+ { "∽", { 8765, 0 } },
+ { "⋍", { 8909, 0 } },
+ { "⊽", { 8893, 0 } },
+ { "⌅", { 8965, 0 } },
+ { "⌅", { 8965, 0 } },
+ { "⎵", { 9141, 0 } },
+ { "⎶", { 9142, 0 } },
+ { "≌", { 8780, 0 } },
+ { "б", { 1073, 0 } },
+ { "„", { 8222, 0 } },
+ { "∵", { 8757, 0 } },
+ { "∵", { 8757, 0 } },
+ { "⦰", { 10672, 0 } },
+ { "϶", { 1014, 0 } },
+ { "ℬ", { 8492, 0 } },
+ { "β", { 946, 0 } },
+ { "ℶ", { 8502, 0 } },
+ { "≬", { 8812, 0 } },
+ { "𝔟", { 120095, 0 } },
+ { "⋂", { 8898, 0 } },
+ { "◯", { 9711, 0 } },
+ { "⋃", { 8899, 0 } },
+ { "⨀", { 10752, 0 } },
+ { "⨁", { 10753, 0 } },
+ { "⨂", { 10754, 0 } },
+ { "⨆", { 10758, 0 } },
+ { "★", { 9733, 0 } },
+ { "▽", { 9661, 0 } },
+ { "△", { 9651, 0 } },
+ { "⨄", { 10756, 0 } },
+ { "⋁", { 8897, 0 } },
+ { "⋀", { 8896, 0 } },
+ { "⤍", { 10509, 0 } },
+ { "⧫", { 10731, 0 } },
+ { "▪", { 9642, 0 } },
+ { "▴", { 9652, 0 } },
+ { "▾", { 9662, 0 } },
+ { "◂", { 9666, 0 } },
+ { "▸", { 9656, 0 } },
+ { "␣", { 9251, 0 } },
+ { "▒", { 9618, 0 } },
+ { "░", { 9617, 0 } },
+ { "▓", { 9619, 0 } },
+ { "█", { 9608, 0 } },
+ { "=⃥", { 61, 8421 } },
+ { "≡⃥", { 8801, 8421 } },
+ { "⌐", { 8976, 0 } },
+ { "𝕓", { 120147, 0 } },
+ { "⊥", { 8869, 0 } },
+ { "⊥", { 8869, 0 } },
+ { "⋈", { 8904, 0 } },
+ { "╗", { 9559, 0 } },
+ { "╔", { 9556, 0 } },
+ { "╖", { 9558, 0 } },
+ { "╓", { 9555, 0 } },
+ { "═", { 9552, 0 } },
+ { "╦", { 9574, 0 } },
+ { "╩", { 9577, 0 } },
+ { "╤", { 9572, 0 } },
+ { "╧", { 9575, 0 } },
+ { "╝", { 9565, 0 } },
+ { "╚", { 9562, 0 } },
+ { "╜", { 9564, 0 } },
+ { "╙", { 9561, 0 } },
+ { "║", { 9553, 0 } },
+ { "╬", { 9580, 0 } },
+ { "╣", { 9571, 0 } },
+ { "╠", { 9568, 0 } },
+ { "╫", { 9579, 0 } },
+ { "╢", { 9570, 0 } },
+ { "╟", { 9567, 0 } },
+ { "⧉", { 10697, 0 } },
+ { "╕", { 9557, 0 } },
+ { "╒", { 9554, 0 } },
+ { "┐", { 9488, 0 } },
+ { "┌", { 9484, 0 } },
+ { "─", { 9472, 0 } },
+ { "╥", { 9573, 0 } },
+ { "╨", { 9576, 0 } },
+ { "┬", { 9516, 0 } },
+ { "┴", { 9524, 0 } },
+ { "⊟", { 8863, 0 } },
+ { "⊞", { 8862, 0 } },
+ { "⊠", { 8864, 0 } },
+ { "╛", { 9563, 0 } },
+ { "╘", { 9560, 0 } },
+ { "┘", { 9496, 0 } },
+ { "└", { 9492, 0 } },
+ { "│", { 9474, 0 } },
+ { "╪", { 9578, 0 } },
+ { "╡", { 9569, 0 } },
+ { "╞", { 9566, 0 } },
+ { "┼", { 9532, 0 } },
+ { "┤", { 9508, 0 } },
+ { "├", { 9500, 0 } },
+ { "‵", { 8245, 0 } },
+ { "˘", { 728, 0 } },
+ { "¦", { 166, 0 } },
+ { "𝒷", { 119991, 0 } },
+ { "⁏", { 8271, 0 } },
+ { "∽", { 8765, 0 } },
+ { "⋍", { 8909, 0 } },
+ { "\", { 92, 0 } },
+ { "⧅", { 10693, 0 } },
+ { "⟈", { 10184, 0 } },
+ { "•", { 8226, 0 } },
+ { "•", { 8226, 0 } },
+ { "≎", { 8782, 0 } },
+ { "⪮", { 10926, 0 } },
+ { "≏", { 8783, 0 } },
+ { "≏", { 8783, 0 } },
+ { "ć", { 263, 0 } },
+ { "∩", { 8745, 0 } },
+ { "⩄", { 10820, 0 } },
+ { "⩉", { 10825, 0 } },
+ { "⩋", { 10827, 0 } },
+ { "⩇", { 10823, 0 } },
+ { "⩀", { 10816, 0 } },
+ { "∩︀", { 8745, 65024 } },
+ { "⁁", { 8257, 0 } },
+ { "ˇ", { 711, 0 } },
+ { "⩍", { 10829, 0 } },
+ { "č", { 269, 0 } },
+ { "ç", { 231, 0 } },
+ { "ĉ", { 265, 0 } },
+ { "⩌", { 10828, 0 } },
+ { "⩐", { 10832, 0 } },
+ { "ċ", { 267, 0 } },
+ { "¸", { 184, 0 } },
+ { "⦲", { 10674, 0 } },
+ { "¢", { 162, 0 } },
+ { "·", { 183, 0 } },
+ { "𝔠", { 120096, 0 } },
+ { "ч", { 1095, 0 } },
+ { "✓", { 10003, 0 } },
+ { "✓", { 10003, 0 } },
+ { "χ", { 967, 0 } },
+ { "○", { 9675, 0 } },
+ { "⧃", { 10691, 0 } },
+ { "ˆ", { 710, 0 } },
+ { "≗", { 8791, 0 } },
+ { "↺", { 8634, 0 } },
+ { "↻", { 8635, 0 } },
+ { "®", { 174, 0 } },
+ { "Ⓢ", { 9416, 0 } },
+ { "⊛", { 8859, 0 } },
+ { "⊚", { 8858, 0 } },
+ { "⊝", { 8861, 0 } },
+ { "≗", { 8791, 0 } },
+ { "⨐", { 10768, 0 } },
+ { "⫯", { 10991, 0 } },
+ { "⧂", { 10690, 0 } },
+ { "♣", { 9827, 0 } },
+ { "♣", { 9827, 0 } },
+ { ":", { 58, 0 } },
+ { "≔", { 8788, 0 } },
+ { "≔", { 8788, 0 } },
+ { ",", { 44, 0 } },
+ { "@", { 64, 0 } },
+ { "∁", { 8705, 0 } },
+ { "∘", { 8728, 0 } },
+ { "∁", { 8705, 0 } },
+ { "ℂ", { 8450, 0 } },
+ { "≅", { 8773, 0 } },
+ { "⩭", { 10861, 0 } },
+ { "∮", { 8750, 0 } },
+ { "𝕔", { 120148, 0 } },
+ { "∐", { 8720, 0 } },
+ { "©", { 169, 0 } },
+ { "℗", { 8471, 0 } },
+ { "↵", { 8629, 0 } },
+ { "✗", { 10007, 0 } },
+ { "𝒸", { 119992, 0 } },
+ { "⫏", { 10959, 0 } },
+ { "⫑", { 10961, 0 } },
+ { "⫐", { 10960, 0 } },
+ { "⫒", { 10962, 0 } },
+ { "⋯", { 8943, 0 } },
+ { "⤸", { 10552, 0 } },
+ { "⤵", { 10549, 0 } },
+ { "⋞", { 8926, 0 } },
+ { "⋟", { 8927, 0 } },
+ { "↶", { 8630, 0 } },
+ { "⤽", { 10557, 0 } },
+ { "∪", { 8746, 0 } },
+ { "⩈", { 10824, 0 } },
+ { "⩆", { 10822, 0 } },
+ { "⩊", { 10826, 0 } },
+ { "⊍", { 8845, 0 } },
+ { "⩅", { 10821, 0 } },
+ { "∪︀", { 8746, 65024 } },
+ { "↷", { 8631, 0 } },
+ { "⤼", { 10556, 0 } },
+ { "⋞", { 8926, 0 } },
+ { "⋟", { 8927, 0 } },
+ { "⋎", { 8910, 0 } },
+ { "⋏", { 8911, 0 } },
+ { "¤", { 164, 0 } },
+ { "↶", { 8630, 0 } },
+ { "↷", { 8631, 0 } },
+ { "⋎", { 8910, 0 } },
+ { "⋏", { 8911, 0 } },
+ { "∲", { 8754, 0 } },
+ { "∱", { 8753, 0 } },
+ { "⌭", { 9005, 0 } },
+ { "⇓", { 8659, 0 } },
+ { "⥥", { 10597, 0 } },
+ { "†", { 8224, 0 } },
+ { "ℸ", { 8504, 0 } },
+ { "↓", { 8595, 0 } },
+ { "‐", { 8208, 0 } },
+ { "⊣", { 8867, 0 } },
+ { "⤏", { 10511, 0 } },
+ { "˝", { 733, 0 } },
+ { "ď", { 271, 0 } },
+ { "д", { 1076, 0 } },
+ { "ⅆ", { 8518, 0 } },
+ { "‡", { 8225, 0 } },
+ { "⇊", { 8650, 0 } },
+ { "⩷", { 10871, 0 } },
+ { "°", { 176, 0 } },
+ { "δ", { 948, 0 } },
+ { "⦱", { 10673, 0 } },
+ { "⥿", { 10623, 0 } },
+ { "𝔡", { 120097, 0 } },
+ { "⇃", { 8643, 0 } },
+ { "⇂", { 8642, 0 } },
+ { "⋄", { 8900, 0 } },
+ { "⋄", { 8900, 0 } },
+ { "♦", { 9830, 0 } },
+ { "♦", { 9830, 0 } },
+ { "¨", { 168, 0 } },
+ { "ϝ", { 989, 0 } },
+ { "⋲", { 8946, 0 } },
+ { "÷", { 247, 0 } },
+ { "÷", { 247, 0 } },
+ { "⋇", { 8903, 0 } },
+ { "⋇", { 8903, 0 } },
+ { "ђ", { 1106, 0 } },
+ { "⌞", { 8990, 0 } },
+ { "⌍", { 8973, 0 } },
+ { "$", { 36, 0 } },
+ { "𝕕", { 120149, 0 } },
+ { "˙", { 729, 0 } },
+ { "≐", { 8784, 0 } },
+ { "≑", { 8785, 0 } },
+ { "∸", { 8760, 0 } },
+ { "∔", { 8724, 0 } },
+ { "⊡", { 8865, 0 } },
+ { "⌆", { 8966, 0 } },
+ { "↓", { 8595, 0 } },
+ { "⇊", { 8650, 0 } },
+ { "⇃", { 8643, 0 } },
+ { "⇂", { 8642, 0 } },
+ { "⤐", { 10512, 0 } },
+ { "⌟", { 8991, 0 } },
+ { "⌌", { 8972, 0 } },
+ { "𝒹", { 119993, 0 } },
+ { "ѕ", { 1109, 0 } },
+ { "⧶", { 10742, 0 } },
+ { "đ", { 273, 0 } },
+ { "⋱", { 8945, 0 } },
+ { "▿", { 9663, 0 } },
+ { "▾", { 9662, 0 } },
+ { "⇵", { 8693, 0 } },
+ { "⥯", { 10607, 0 } },
+ { "⦦", { 10662, 0 } },
+ { "џ", { 1119, 0 } },
+ { "⟿", { 10239, 0 } },
+ { "⩷", { 10871, 0 } },
+ { "≑", { 8785, 0 } },
+ { "é", { 233, 0 } },
+ { "⩮", { 10862, 0 } },
+ { "ě", { 283, 0 } },
+ { "≖", { 8790, 0 } },
+ { "ê", { 234, 0 } },
+ { "≕", { 8789, 0 } },
+ { "э", { 1101, 0 } },
+ { "ė", { 279, 0 } },
+ { "ⅇ", { 8519, 0 } },
+ { "≒", { 8786, 0 } },
+ { "𝔢", { 120098, 0 } },
+ { "⪚", { 10906, 0 } },
+ { "è", { 232, 0 } },
+ { "⪖", { 10902, 0 } },
+ { "⪘", { 10904, 0 } },
+ { "⪙", { 10905, 0 } },
+ { "⏧", { 9191, 0 } },
+ { "ℓ", { 8467, 0 } },
+ { "⪕", { 10901, 0 } },
+ { "⪗", { 10903, 0 } },
+ { "ē", { 275, 0 } },
+ { "∅", { 8709, 0 } },
+ { "∅", { 8709, 0 } },
+ { "∅", { 8709, 0 } },
+ { " ", { 8196, 0 } },
+ { " ", { 8197, 0 } },
+ { " ", { 8195, 0 } },
+ { "ŋ", { 331, 0 } },
+ { " ", { 8194, 0 } },
+ { "ę", { 281, 0 } },
+ { "𝕖", { 120150, 0 } },
+ { "⋕", { 8917, 0 } },
+ { "⧣", { 10723, 0 } },
+ { "⩱", { 10865, 0 } },
+ { "ε", { 949, 0 } },
+ { "ε", { 949, 0 } },
+ { "ϵ", { 1013, 0 } },
+ { "≖", { 8790, 0 } },
+ { "≕", { 8789, 0 } },
+ { "≂", { 8770, 0 } },
+ { "⪖", { 10902, 0 } },
+ { "⪕", { 10901, 0 } },
+ { "=", { 61, 0 } },
+ { "≟", { 8799, 0 } },
+ { "≡", { 8801, 0 } },
+ { "⩸", { 10872, 0 } },
+ { "⧥", { 10725, 0 } },
+ { "≓", { 8787, 0 } },
+ { "⥱", { 10609, 0 } },
+ { "ℯ", { 8495, 0 } },
+ { "≐", { 8784, 0 } },
+ { "≂", { 8770, 0 } },
+ { "η", { 951, 0 } },
+ { "ð", { 240, 0 } },
+ { "ë", { 235, 0 } },
+ { "€", { 8364, 0 } },
+ { "!", { 33, 0 } },
+ { "∃", { 8707, 0 } },
+ { "ℰ", { 8496, 0 } },
+ { "ⅇ", { 8519, 0 } },
+ { "≒", { 8786, 0 } },
+ { "ф", { 1092, 0 } },
+ { "♀", { 9792, 0 } },
+ { "ffi", { 64259, 0 } },
+ { "ff", { 64256, 0 } },
+ { "ffl", { 64260, 0 } },
+ { "𝔣", { 120099, 0 } },
+ { "fi", { 64257, 0 } },
+ { "fj", { 102, 106 } },
+ { "♭", { 9837, 0 } },
+ { "fl", { 64258, 0 } },
+ { "▱", { 9649, 0 } },
+ { "ƒ", { 402, 0 } },
+ { "𝕗", { 120151, 0 } },
+ { "∀", { 8704, 0 } },
+ { "⋔", { 8916, 0 } },
+ { "⫙", { 10969, 0 } },
+ { "⨍", { 10765, 0 } },
+ { "½", { 189, 0 } },
+ { "½", { 189, 0 } },
+ { "⅓", { 8531, 0 } },
+ { "¼", { 188, 0 } },
+ { "¼", { 188, 0 } },
+ { "⅕", { 8533, 0 } },
+ { "⅙", { 8537, 0 } },
+ { "⅛", { 8539, 0 } },
+ { "⅔", { 8532, 0 } },
+ { "⅖", { 8534, 0 } },
+ { "¾", { 190, 0 } },
+ { "¾", { 190, 0 } },
+ { "⅗", { 8535, 0 } },
+ { "⅜", { 8540, 0 } },
+ { "⅘", { 8536, 0 } },
+ { "⅚", { 8538, 0 } },
+ { "⅝", { 8541, 0 } },
+ { "⅞", { 8542, 0 } },
+ { "⁄", { 8260, 0 } },
+ { "⌢", { 8994, 0 } },
+ { "𝒻", { 119995, 0 } },
+ { "≧", { 8807, 0 } },
+ { "⪌", { 10892, 0 } },
+ { "ǵ", { 501, 0 } },
+ { "γ", { 947, 0 } },
+ { "ϝ", { 989, 0 } },
+ { "⪆", { 10886, 0 } },
+ { "ğ", { 287, 0 } },
+ { "ĝ", { 285, 0 } },
+ { "г", { 1075, 0 } },
+ { "ġ", { 289, 0 } },
+ { "≥", { 8805, 0 } },
+ { "⋛", { 8923, 0 } },
+ { "≥", { 8805, 0 } },
+ { "≧", { 8807, 0 } },
+ { "⩾", { 10878, 0 } },
+ { "⩾", { 10878, 0 } },
+ { "⪩", { 10921, 0 } },
+ { "⪀", { 10880, 0 } },
+ { "⪂", { 10882, 0 } },
+ { "⪄", { 10884, 0 } },
+ { "⋛︀", { 8923, 65024 } },
+ { "⪔", { 10900, 0 } },
+ { "𝔤", { 120100, 0 } },
+ { "≫", { 8811, 0 } },
+ { "⋙", { 8921, 0 } },
+ { "ℷ", { 8503, 0 } },
+ { "ѓ", { 1107, 0 } },
+ { "≷", { 8823, 0 } },
+ { "⪒", { 10898, 0 } },
+ { "⪥", { 10917, 0 } },
+ { "⪤", { 10916, 0 } },
+ { "≩", { 8809, 0 } },
+ { "⪊", { 10890, 0 } },
+ { "⪊", { 10890, 0 } },
+ { "⪈", { 10888, 0 } },
+ { "⪈", { 10888, 0 } },
+ { "≩", { 8809, 0 } },
+ { "⋧", { 8935, 0 } },
+ { "𝕘", { 120152, 0 } },
+ { "`", { 96, 0 } },
+ { "ℊ", { 8458, 0 } },
+ { "≳", { 8819, 0 } },
+ { "⪎", { 10894, 0 } },
+ { "⪐", { 10896, 0 } },
+ { ">", { 62, 0 } },
+ { "⪧", { 10919, 0 } },
+ { "⩺", { 10874, 0 } },
+ { "⋗", { 8919, 0 } },
+ { "⦕", { 10645, 0 } },
+ { "⩼", { 10876, 0 } },
+ { "⪆", { 10886, 0 } },
+ { "⥸", { 10616, 0 } },
+ { "⋗", { 8919, 0 } },
+ { "⋛", { 8923, 0 } },
+ { "⪌", { 10892, 0 } },
+ { "≷", { 8823, 0 } },
+ { "≳", { 8819, 0 } },
+ { "≩︀", { 8809, 65024 } },
+ { "≩︀", { 8809, 65024 } },
+ { "⇔", { 8660, 0 } },
+ { " ", { 8202, 0 } },
+ { "½", { 189, 0 } },
+ { "ℋ", { 8459, 0 } },
+ { "ъ", { 1098, 0 } },
+ { "↔", { 8596, 0 } },
+ { "⥈", { 10568, 0 } },
+ { "↭", { 8621, 0 } },
+ { "ℏ", { 8463, 0 } },
+ { "ĥ", { 293, 0 } },
+ { "♥", { 9829, 0 } },
+ { "♥", { 9829, 0 } },
+ { "…", { 8230, 0 } },
+ { "⊹", { 8889, 0 } },
+ { "𝔥", { 120101, 0 } },
+ { "⤥", { 10533, 0 } },
+ { "⤦", { 10534, 0 } },
+ { "⇿", { 8703, 0 } },
+ { "∻", { 8763, 0 } },
+ { "↩", { 8617, 0 } },
+ { "↪", { 8618, 0 } },
+ { "𝕙", { 120153, 0 } },
+ { "―", { 8213, 0 } },
+ { "𝒽", { 119997, 0 } },
+ { "ℏ", { 8463, 0 } },
+ { "ħ", { 295, 0 } },
+ { "⁃", { 8259, 0 } },
+ { "‐", { 8208, 0 } },
+ { "í", { 237, 0 } },
+ { "⁣", { 8291, 0 } },
+ { "î", { 238, 0 } },
+ { "и", { 1080, 0 } },
+ { "е", { 1077, 0 } },
+ { "¡", { 161, 0 } },
+ { "⇔", { 8660, 0 } },
+ { "𝔦", { 120102, 0 } },
+ { "ì", { 236, 0 } },
+ { "ⅈ", { 8520, 0 } },
+ { "⨌", { 10764, 0 } },
+ { "∭", { 8749, 0 } },
+ { "⧜", { 10716, 0 } },
+ { "℩", { 8489, 0 } },
+ { "ij", { 307, 0 } },
+ { "ī", { 299, 0 } },
+ { "ℑ", { 8465, 0 } },
+ { "ℐ", { 8464, 0 } },
+ { "ℑ", { 8465, 0 } },
+ { "ı", { 305, 0 } },
+ { "⊷", { 8887, 0 } },
+ { "Ƶ", { 437, 0 } },
+ { "∈", { 8712, 0 } },
+ { "℅", { 8453, 0 } },
+ { "∞", { 8734, 0 } },
+ { "⧝", { 10717, 0 } },
+ { "ı", { 305, 0 } },
+ { "∫", { 8747, 0 } },
+ { "⊺", { 8890, 0 } },
+ { "ℤ", { 8484, 0 } },
+ { "⊺", { 8890, 0 } },
+ { "⨗", { 10775, 0 } },
+ { "⨼", { 10812, 0 } },
+ { "ё", { 1105, 0 } },
+ { "į", { 303, 0 } },
+ { "𝕚", { 120154, 0 } },
+ { "ι", { 953, 0 } },
+ { "⨼", { 10812, 0 } },
+ { "¿", { 191, 0 } },
+ { "𝒾", { 119998, 0 } },
+ { "∈", { 8712, 0 } },
+ { "⋹", { 8953, 0 } },
+ { "⋵", { 8949, 0 } },
+ { "⋴", { 8948, 0 } },
+ { "⋳", { 8947, 0 } },
+ { "∈", { 8712, 0 } },
+ { "⁢", { 8290, 0 } },
+ { "ĩ", { 297, 0 } },
+ { "і", { 1110, 0 } },
+ { "ï", { 239, 0 } },
+ { "ĵ", { 309, 0 } },
+ { "й", { 1081, 0 } },
+ { "𝔧", { 120103, 0 } },
+ { "ȷ", { 567, 0 } },
+ { "𝕛", { 120155, 0 } },
+ { "𝒿", { 119999, 0 } },
+ { "ј", { 1112, 0 } },
+ { "є", { 1108, 0 } },
+ { "κ", { 954, 0 } },
+ { "ϰ", { 1008, 0 } },
+ { "ķ", { 311, 0 } },
+ { "к", { 1082, 0 } },
+ { "𝔨", { 120104, 0 } },
+ { "ĸ", { 312, 0 } },
+ { "х", { 1093, 0 } },
+ { "ќ", { 1116, 0 } },
+ { "𝕜", { 120156, 0 } },
+ { "𝓀", { 120000, 0 } },
+ { "⇚", { 8666, 0 } },
+ { "⇐", { 8656, 0 } },
+ { "⤛", { 10523, 0 } },
+ { "⤎", { 10510, 0 } },
+ { "≦", { 8806, 0 } },
+ { "⪋", { 10891, 0 } },
+ { "⥢", { 10594, 0 } },
+ { "ĺ", { 314, 0 } },
+ { "⦴", { 10676, 0 } },
+ { "ℒ", { 8466, 0 } },
+ { "λ", { 955, 0 } },
+ { "⟨", { 10216, 0 } },
+ { "⦑", { 10641, 0 } },
+ { "⟨", { 10216, 0 } },
+ { "⪅", { 10885, 0 } },
+ { "«", { 171, 0 } },
+ { "←", { 8592, 0 } },
+ { "⇤", { 8676, 0 } },
+ { "⤟", { 10527, 0 } },
+ { "⤝", { 10525, 0 } },
+ { "↩", { 8617, 0 } },
+ { "↫", { 8619, 0 } },
+ { "⤹", { 10553, 0 } },
+ { "⥳", { 10611, 0 } },
+ { "↢", { 8610, 0 } },
+ { "⪫", { 10923, 0 } },
+ { "⤙", { 10521, 0 } },
+ { "⪭", { 10925, 0 } },
+ { "⪭︀", { 10925, 65024 } },
+ { "⤌", { 10508, 0 } },
+ { "❲", { 10098, 0 } },
+ { "{", { 123, 0 } },
+ { "[", { 91, 0 } },
+ { "⦋", { 10635, 0 } },
+ { "⦏", { 10639, 0 } },
+ { "⦍", { 10637, 0 } },
+ { "ľ", { 318, 0 } },
+ { "ļ", { 316, 0 } },
+ { "⌈", { 8968, 0 } },
+ { "{", { 123, 0 } },
+ { "л", { 1083, 0 } },
+ { "⤶", { 10550, 0 } },
+ { "“", { 8220, 0 } },
+ { "„", { 8222, 0 } },
+ { "⥧", { 10599, 0 } },
+ { "⥋", { 10571, 0 } },
+ { "↲", { 8626, 0 } },
+ { "≤", { 8804, 0 } },
+ { "←", { 8592, 0 } },
+ { "↢", { 8610, 0 } },
+ { "↽", { 8637, 0 } },
+ { "↼", { 8636, 0 } },
+ { "⇇", { 8647, 0 } },
+ { "↔", { 8596, 0 } },
+ { "⇆", { 8646, 0 } },
+ { "⇋", { 8651, 0 } },
+ { "↭", { 8621, 0 } },
+ { "⋋", { 8907, 0 } },
+ { "⋚", { 8922, 0 } },
+ { "≤", { 8804, 0 } },
+ { "≦", { 8806, 0 } },
+ { "⩽", { 10877, 0 } },
+ { "⩽", { 10877, 0 } },
+ { "⪨", { 10920, 0 } },
+ { "⩿", { 10879, 0 } },
+ { "⪁", { 10881, 0 } },
+ { "⪃", { 10883, 0 } },
+ { "⋚︀", { 8922, 65024 } },
+ { "⪓", { 10899, 0 } },
+ { "⪅", { 10885, 0 } },
+ { "⋖", { 8918, 0 } },
+ { "⋚", { 8922, 0 } },
+ { "⪋", { 10891, 0 } },
+ { "≶", { 8822, 0 } },
+ { "≲", { 8818, 0 } },
+ { "⥼", { 10620, 0 } },
+ { "⌊", { 8970, 0 } },
+ { "𝔩", { 120105, 0 } },
+ { "≶", { 8822, 0 } },
+ { "⪑", { 10897, 0 } },
+ { "↽", { 8637, 0 } },
+ { "↼", { 8636, 0 } },
+ { "⥪", { 10602, 0 } },
+ { "▄", { 9604, 0 } },
+ { "љ", { 1113, 0 } },
+ { "≪", { 8810, 0 } },
+ { "⇇", { 8647, 0 } },
+ { "⌞", { 8990, 0 } },
+ { "⥫", { 10603, 0 } },
+ { "◺", { 9722, 0 } },
+ { "ŀ", { 320, 0 } },
+ { "⎰", { 9136, 0 } },
+ { "⎰", { 9136, 0 } },
+ { "≨", { 8808, 0 } },
+ { "⪉", { 10889, 0 } },
+ { "⪉", { 10889, 0 } },
+ { "⪇", { 10887, 0 } },
+ { "⪇", { 10887, 0 } },
+ { "≨", { 8808, 0 } },
+ { "⋦", { 8934, 0 } },
+ { "⟬", { 10220, 0 } },
+ { "⇽", { 8701, 0 } },
+ { "⟦", { 10214, 0 } },
+ { "⟵", { 10229, 0 } },
+ { "⟷", { 10231, 0 } },
+ { "⟼", { 10236, 0 } },
+ { "⟶", { 10230, 0 } },
+ { "↫", { 8619, 0 } },
+ { "↬", { 8620, 0 } },
+ { "⦅", { 10629, 0 } },
+ { "𝕝", { 120157, 0 } },
+ { "⨭", { 10797, 0 } },
+ { "⨴", { 10804, 0 } },
+ { "∗", { 8727, 0 } },
+ { "_", { 95, 0 } },
+ { "◊", { 9674, 0 } },
+ { "◊", { 9674, 0 } },
+ { "⧫", { 10731, 0 } },
+ { "(", { 40, 0 } },
+ { "⦓", { 10643, 0 } },
+ { "⇆", { 8646, 0 } },
+ { "⌟", { 8991, 0 } },
+ { "⇋", { 8651, 0 } },
+ { "⥭", { 10605, 0 } },
+ { "‎", { 8206, 0 } },
+ { "⊿", { 8895, 0 } },
+ { "‹", { 8249, 0 } },
+ { "𝓁", { 120001, 0 } },
+ { "↰", { 8624, 0 } },
+ { "≲", { 8818, 0 } },
+ { "⪍", { 10893, 0 } },
+ { "⪏", { 10895, 0 } },
+ { "[", { 91, 0 } },
+ { "‘", { 8216, 0 } },
+ { "‚", { 8218, 0 } },
+ { "ł", { 322, 0 } },
+ { "<", { 60, 0 } },
+ { "⪦", { 10918, 0 } },
+ { "⩹", { 10873, 0 } },
+ { "⋖", { 8918, 0 } },
+ { "⋋", { 8907, 0 } },
+ { "⋉", { 8905, 0 } },
+ { "⥶", { 10614, 0 } },
+ { "⩻", { 10875, 0 } },
+ { "⦖", { 10646, 0 } },
+ { "◃", { 9667, 0 } },
+ { "⊴", { 8884, 0 } },
+ { "◂", { 9666, 0 } },
+ { "⥊", { 10570, 0 } },
+ { "⥦", { 10598, 0 } },
+ { "≨︀", { 8808, 65024 } },
+ { "≨︀", { 8808, 65024 } },
+ { "∺", { 8762, 0 } },
+ { "¯", { 175, 0 } },
+ { "♂", { 9794, 0 } },
+ { "✠", { 10016, 0 } },
+ { "✠", { 10016, 0 } },
+ { "↦", { 8614, 0 } },
+ { "↦", { 8614, 0 } },
+ { "↧", { 8615, 0 } },
+ { "↤", { 8612, 0 } },
+ { "↥", { 8613, 0 } },
+ { "▮", { 9646, 0 } },
+ { "⨩", { 10793, 0 } },
+ { "м", { 1084, 0 } },
+ { "—", { 8212, 0 } },
+ { "∡", { 8737, 0 } },
+ { "𝔪", { 120106, 0 } },
+ { "℧", { 8487, 0 } },
+ { "µ", { 181, 0 } },
+ { "∣", { 8739, 0 } },
+ { "*", { 42, 0 } },
+ { "⫰", { 10992, 0 } },
+ { "·", { 183, 0 } },
+ { "−", { 8722, 0 } },
+ { "⊟", { 8863, 0 } },
+ { "∸", { 8760, 0 } },
+ { "⨪", { 10794, 0 } },
+ { "⫛", { 10971, 0 } },
+ { "…", { 8230, 0 } },
+ { "∓", { 8723, 0 } },
+ { "⊧", { 8871, 0 } },
+ { "𝕞", { 120158, 0 } },
+ { "∓", { 8723, 0 } },
+ { "𝓂", { 120002, 0 } },
+ { "∾", { 8766, 0 } },
+ { "μ", { 956, 0 } },
+ { "⊸", { 8888, 0 } },
+ { "⊸", { 8888, 0 } },
+ { "⋙̸", { 8921, 824 } },
+ { "≫⃒", { 8811, 8402 } },
+ { "≫̸", { 8811, 824 } },
+ { "⇍", { 8653, 0 } },
+ { "⇎", { 8654, 0 } },
+ { "⋘̸", { 8920, 824 } },
+ { "≪⃒", { 8810, 8402 } },
+ { "≪̸", { 8810, 824 } },
+ { "⇏", { 8655, 0 } },
+ { "⊯", { 8879, 0 } },
+ { "⊮", { 8878, 0 } },
+ { "∇", { 8711, 0 } },
+ { "ń", { 324, 0 } },
+ { "∠⃒", { 8736, 8402 } },
+ { "≉", { 8777, 0 } },
+ { "⩰̸", { 10864, 824 } },
+ { "≋̸", { 8779, 824 } },
+ { "ʼn", { 329, 0 } },
+ { "≉", { 8777, 0 } },
+ { "♮", { 9838, 0 } },
+ { "♮", { 9838, 0 } },
+ { "ℕ", { 8469, 0 } },
+ { " ", { 160, 0 } },
+ { "≎̸", { 8782, 824 } },
+ { "≏̸", { 8783, 824 } },
+ { "⩃", { 10819, 0 } },
+ { "ň", { 328, 0 } },
+ { "ņ", { 326, 0 } },
+ { "≇", { 8775, 0 } },
+ { "⩭̸", { 10861, 824 } },
+ { "⩂", { 10818, 0 } },
+ { "н", { 1085, 0 } },
+ { "–", { 8211, 0 } },
+ { "≠", { 8800, 0 } },
+ { "⇗", { 8663, 0 } },
+ { "⤤", { 10532, 0 } },
+ { "↗", { 8599, 0 } },
+ { "↗", { 8599, 0 } },
+ { "≐̸", { 8784, 824 } },
+ { "≢", { 8802, 0 } },
+ { "⤨", { 10536, 0 } },
+ { "≂̸", { 8770, 824 } },
+ { "∄", { 8708, 0 } },
+ { "∄", { 8708, 0 } },
+ { "𝔫", { 120107, 0 } },
+ { "≧̸", { 8807, 824 } },
+ { "≱", { 8817, 0 } },
+ { "≱", { 8817, 0 } },
+ { "≧̸", { 8807, 824 } },
+ { "⩾̸", { 10878, 824 } },
+ { "⩾̸", { 10878, 824 } },
+ { "≵", { 8821, 0 } },
+ { "≯", { 8815, 0 } },
+ { "≯", { 8815, 0 } },
+ { "⇎", { 8654, 0 } },
+ { "↮", { 8622, 0 } },
+ { "⫲", { 10994, 0 } },
+ { "∋", { 8715, 0 } },
+ { "⋼", { 8956, 0 } },
+ { "⋺", { 8954, 0 } },
+ { "∋", { 8715, 0 } },
+ { "њ", { 1114, 0 } },
+ { "⇍", { 8653, 0 } },
+ { "≦̸", { 8806, 824 } },
+ { "↚", { 8602, 0 } },
+ { "‥", { 8229, 0 } },
+ { "≰", { 8816, 0 } },
+ { "↚", { 8602, 0 } },
+ { "↮", { 8622, 0 } },
+ { "≰", { 8816, 0 } },
+ { "≦̸", { 8806, 824 } },
+ { "⩽̸", { 10877, 824 } },
+ { "⩽̸", { 10877, 824 } },
+ { "≮", { 8814, 0 } },
+ { "≴", { 8820, 0 } },
+ { "≮", { 8814, 0 } },
+ { "⋪", { 8938, 0 } },
+ { "⋬", { 8940, 0 } },
+ { "∤", { 8740, 0 } },
+ { "𝕟", { 120159, 0 } },
+ { "¬", { 172, 0 } },
+ { "∉", { 8713, 0 } },
+ { "⋹̸", { 8953, 824 } },
+ { "⋵̸", { 8949, 824 } },
+ { "∉", { 8713, 0 } },
+ { "⋷", { 8951, 0 } },
+ { "⋶", { 8950, 0 } },
+ { "∌", { 8716, 0 } },
+ { "∌", { 8716, 0 } },
+ { "⋾", { 8958, 0 } },
+ { "⋽", { 8957, 0 } },
+ { "∦", { 8742, 0 } },
+ { "∦", { 8742, 0 } },
+ { "⫽⃥", { 11005, 8421 } },
+ { "∂̸", { 8706, 824 } },
+ { "⨔", { 10772, 0 } },
+ { "⊀", { 8832, 0 } },
+ { "⋠", { 8928, 0 } },
+ { "⪯̸", { 10927, 824 } },
+ { "⊀", { 8832, 0 } },
+ { "⪯̸", { 10927, 824 } },
+ { "⇏", { 8655, 0 } },
+ { "↛", { 8603, 0 } },
+ { "⤳̸", { 10547, 824 } },
+ { "↝̸", { 8605, 824 } },
+ { "↛", { 8603, 0 } },
+ { "⋫", { 8939, 0 } },
+ { "⋭", { 8941, 0 } },
+ { "⊁", { 8833, 0 } },
+ { "⋡", { 8929, 0 } },
+ { "⪰̸", { 10928, 824 } },
+ { "𝓃", { 120003, 0 } },
+ { "∤", { 8740, 0 } },
+ { "∦", { 8742, 0 } },
+ { "≁", { 8769, 0 } },
+ { "≄", { 8772, 0 } },
+ { "≄", { 8772, 0 } },
+ { "∤", { 8740, 0 } },
+ { "∦", { 8742, 0 } },
+ { "⋢", { 8930, 0 } },
+ { "⋣", { 8931, 0 } },
+ { "⊄", { 8836, 0 } },
+ { "⫅̸", { 10949, 824 } },
+ { "⊈", { 8840, 0 } },
+ { "⊂⃒", { 8834, 8402 } },
+ { "⊈", { 8840, 0 } },
+ { "⫅̸", { 10949, 824 } },
+ { "⊁", { 8833, 0 } },
+ { "⪰̸", { 10928, 824 } },
+ { "⊅", { 8837, 0 } },
+ { "⫆̸", { 10950, 824 } },
+ { "⊉", { 8841, 0 } },
+ { "⊃⃒", { 8835, 8402 } },
+ { "⊉", { 8841, 0 } },
+ { "⫆̸", { 10950, 824 } },
+ { "≹", { 8825, 0 } },
+ { "ñ", { 241, 0 } },
+ { "≸", { 8824, 0 } },
+ { "⋪", { 8938, 0 } },
+ { "⋬", { 8940, 0 } },
+ { "⋫", { 8939, 0 } },
+ { "⋭", { 8941, 0 } },
+ { "ν", { 957, 0 } },
+ { "#", { 35, 0 } },
+ { "№", { 8470, 0 } },
+ { " ", { 8199, 0 } },
+ { "⊭", { 8877, 0 } },
+ { "⤄", { 10500, 0 } },
+ { "≍⃒", { 8781, 8402 } },
+ { "⊬", { 8876, 0 } },
+ { "≥⃒", { 8805, 8402 } },
+ { ">⃒", { 62, 8402 } },
+ { "⧞", { 10718, 0 } },
+ { "⤂", { 10498, 0 } },
+ { "≤⃒", { 8804, 8402 } },
+ { "<⃒", { 60, 8402 } },
+ { "⊴⃒", { 8884, 8402 } },
+ { "⤃", { 10499, 0 } },
+ { "⊵⃒", { 8885, 8402 } },
+ { "∼⃒", { 8764, 8402 } },
+ { "⇖", { 8662, 0 } },
+ { "⤣", { 10531, 0 } },
+ { "↖", { 8598, 0 } },
+ { "↖", { 8598, 0 } },
+ { "⤧", { 10535, 0 } },
+ { "Ⓢ", { 9416, 0 } },
+ { "ó", { 243, 0 } },
+ { "⊛", { 8859, 0 } },
+ { "⊚", { 8858, 0 } },
+ { "ô", { 244, 0 } },
+ { "о", { 1086, 0 } },
+ { "⊝", { 8861, 0 } },
+ { "ő", { 337, 0 } },
+ { "⨸", { 10808, 0 } },
+ { "⊙", { 8857, 0 } },
+ { "⦼", { 10684, 0 } },
+ { "œ", { 339, 0 } },
+ { "⦿", { 10687, 0 } },
+ { "𝔬", { 120108, 0 } },
+ { "˛", { 731, 0 } },
+ { "ò", { 242, 0 } },
+ { "⧁", { 10689, 0 } },
+ { "⦵", { 10677, 0 } },
+ { "Ω", { 937, 0 } },
+ { "∮", { 8750, 0 } },
+ { "↺", { 8634, 0 } },
+ { "⦾", { 10686, 0 } },
+ { "⦻", { 10683, 0 } },
+ { "‾", { 8254, 0 } },
+ { "⧀", { 10688, 0 } },
+ { "ō", { 333, 0 } },
+ { "ω", { 969, 0 } },
+ { "ο", { 959, 0 } },
+ { "⦶", { 10678, 0 } },
+ { "⊖", { 8854, 0 } },
+ { "𝕠", { 120160, 0 } },
+ { "⦷", { 10679, 0 } },
+ { "⦹", { 10681, 0 } },
+ { "⊕", { 8853, 0 } },
+ { "∨", { 8744, 0 } },
+ { "↻", { 8635, 0 } },
+ { "⩝", { 10845, 0 } },
+ { "ℴ", { 8500, 0 } },
+ { "ℴ", { 8500, 0 } },
+ { "ª", { 170, 0 } },
+ { "º", { 186, 0 } },
+ { "⊶", { 8886, 0 } },
+ { "⩖", { 10838, 0 } },
+ { "⩗", { 10839, 0 } },
+ { "⩛", { 10843, 0 } },
+ { "ℴ", { 8500, 0 } },
+ { "ø", { 248, 0 } },
+ { "⊘", { 8856, 0 } },
+ { "õ", { 245, 0 } },
+ { "⊗", { 8855, 0 } },
+ { "⨶", { 10806, 0 } },
+ { "ö", { 246, 0 } },
+ { "⌽", { 9021, 0 } },
+ { "∥", { 8741, 0 } },
+ { "¶", { 182, 0 } },
+ { "∥", { 8741, 0 } },
+ { "⫳", { 10995, 0 } },
+ { "⫽", { 11005, 0 } },
+ { "∂", { 8706, 0 } },
+ { "п", { 1087, 0 } },
+ { "%", { 37, 0 } },
+ { ".", { 46, 0 } },
+ { "‰", { 8240, 0 } },
+ { "⊥", { 8869, 0 } },
+ { "‱", { 8241, 0 } },
+ { "𝔭", { 120109, 0 } },
+ { "φ", { 966, 0 } },
+ { "ϕ", { 981, 0 } },
+ { "ℳ", { 8499, 0 } },
+ { "☎", { 9742, 0 } },
+ { "π", { 960, 0 } },
+ { "⋔", { 8916, 0 } },
+ { "ϖ", { 982, 0 } },
+ { "ℏ", { 8463, 0 } },
+ { "ℎ", { 8462, 0 } },
+ { "ℏ", { 8463, 0 } },
+ { "+", { 43, 0 } },
+ { "⨣", { 10787, 0 } },
+ { "⊞", { 8862, 0 } },
+ { "⨢", { 10786, 0 } },
+ { "∔", { 8724, 0 } },
+ { "⨥", { 10789, 0 } },
+ { "⩲", { 10866, 0 } },
+ { "±", { 177, 0 } },
+ { "⨦", { 10790, 0 } },
+ { "⨧", { 10791, 0 } },
+ { "±", { 177, 0 } },
+ { "⨕", { 10773, 0 } },
+ { "𝕡", { 120161, 0 } },
+ { "£", { 163, 0 } },
+ { "≺", { 8826, 0 } },
+ { "⪳", { 10931, 0 } },
+ { "⪷", { 10935, 0 } },
+ { "≼", { 8828, 0 } },
+ { "⪯", { 10927, 0 } },
+ { "≺", { 8826, 0 } },
+ { "⪷", { 10935, 0 } },
+ { "≼", { 8828, 0 } },
+ { "⪯", { 10927, 0 } },
+ { "⪹", { 10937, 0 } },
+ { "⪵", { 10933, 0 } },
+ { "⋨", { 8936, 0 } },
+ { "≾", { 8830, 0 } },
+ { "′", { 8242, 0 } },
+ { "ℙ", { 8473, 0 } },
+ { "⪵", { 10933, 0 } },
+ { "⪹", { 10937, 0 } },
+ { "⋨", { 8936, 0 } },
+ { "∏", { 8719, 0 } },
+ { "⌮", { 9006, 0 } },
+ { "⌒", { 8978, 0 } },
+ { "⌓", { 8979, 0 } },
+ { "∝", { 8733, 0 } },
+ { "∝", { 8733, 0 } },
+ { "≾", { 8830, 0 } },
+ { "⊰", { 8880, 0 } },
+ { "𝓅", { 120005, 0 } },
+ { "ψ", { 968, 0 } },
+ { " ", { 8200, 0 } },
+ { "𝔮", { 120110, 0 } },
+ { "⨌", { 10764, 0 } },
+ { "𝕢", { 120162, 0 } },
+ { "⁗", { 8279, 0 } },
+ { "𝓆", { 120006, 0 } },
+ { "ℍ", { 8461, 0 } },
+ { "⨖", { 10774, 0 } },
+ { "?", { 63, 0 } },
+ { "≟", { 8799, 0 } },
+ { """, { 34, 0 } },
+ { "⇛", { 8667, 0 } },
+ { "⇒", { 8658, 0 } },
+ { "⤜", { 10524, 0 } },
+ { "⤏", { 10511, 0 } },
+ { "⥤", { 10596, 0 } },
+ { "∽̱", { 8765, 817 } },
+ { "ŕ", { 341, 0 } },
+ { "√", { 8730, 0 } },
+ { "⦳", { 10675, 0 } },
+ { "⟩", { 10217, 0 } },
+ { "⦒", { 10642, 0 } },
+ { "⦥", { 10661, 0 } },
+ { "⟩", { 10217, 0 } },
+ { "»", { 187, 0 } },
+ { "→", { 8594, 0 } },
+ { "⥵", { 10613, 0 } },
+ { "⇥", { 8677, 0 } },
+ { "⤠", { 10528, 0 } },
+ { "⤳", { 10547, 0 } },
+ { "⤞", { 10526, 0 } },
+ { "↪", { 8618, 0 } },
+ { "↬", { 8620, 0 } },
+ { "⥅", { 10565, 0 } },
+ { "⥴", { 10612, 0 } },
+ { "↣", { 8611, 0 } },
+ { "↝", { 8605, 0 } },
+ { "⤚", { 10522, 0 } },
+ { "∶", { 8758, 0 } },
+ { "ℚ", { 8474, 0 } },
+ { "⤍", { 10509, 0 } },
+ { "❳", { 10099, 0 } },
+ { "}", { 125, 0 } },
+ { "]", { 93, 0 } },
+ { "⦌", { 10636, 0 } },
+ { "⦎", { 10638, 0 } },
+ { "⦐", { 10640, 0 } },
+ { "ř", { 345, 0 } },
+ { "ŗ", { 343, 0 } },
+ { "⌉", { 8969, 0 } },
+ { "}", { 125, 0 } },
+ { "р", { 1088, 0 } },
+ { "⤷", { 10551, 0 } },
+ { "⥩", { 10601, 0 } },
+ { "”", { 8221, 0 } },
+ { "”", { 8221, 0 } },
+ { "↳", { 8627, 0 } },
+ { "ℜ", { 8476, 0 } },
+ { "ℛ", { 8475, 0 } },
+ { "ℜ", { 8476, 0 } },
+ { "ℝ", { 8477, 0 } },
+ { "▭", { 9645, 0 } },
+ { "®", { 174, 0 } },
+ { "⥽", { 10621, 0 } },
+ { "⌋", { 8971, 0 } },
+ { "𝔯", { 120111, 0 } },
+ { "⇁", { 8641, 0 } },
+ { "⇀", { 8640, 0 } },
+ { "⥬", { 10604, 0 } },
+ { "ρ", { 961, 0 } },
+ { "ϱ", { 1009, 0 } },
+ { "→", { 8594, 0 } },
+ { "↣", { 8611, 0 } },
+ { "⇁", { 8641, 0 } },
+ { "⇀", { 8640, 0 } },
+ { "⇄", { 8644, 0 } },
+ { "⇌", { 8652, 0 } },
+ { "⇉", { 8649, 0 } },
+ { "↝", { 8605, 0 } },
+ { "⋌", { 8908, 0 } },
+ { "˚", { 730, 0 } },
+ { "≓", { 8787, 0 } },
+ { "⇄", { 8644, 0 } },
+ { "⇌", { 8652, 0 } },
+ { "‏", { 8207, 0 } },
+ { "⎱", { 9137, 0 } },
+ { "⎱", { 9137, 0 } },
+ { "⫮", { 10990, 0 } },
+ { "⟭", { 10221, 0 } },
+ { "⇾", { 8702, 0 } },
+ { "⟧", { 10215, 0 } },
+ { "⦆", { 10630, 0 } },
+ { "𝕣", { 120163, 0 } },
+ { "⨮", { 10798, 0 } },
+ { "⨵", { 10805, 0 } },
+ { ")", { 41, 0 } },
+ { "⦔", { 10644, 0 } },
+ { "⨒", { 10770, 0 } },
+ { "⇉", { 8649, 0 } },
+ { "›", { 8250, 0 } },
+ { "𝓇", { 120007, 0 } },
+ { "↱", { 8625, 0 } },
+ { "]", { 93, 0 } },
+ { "’", { 8217, 0 } },
+ { "’", { 8217, 0 } },
+ { "⋌", { 8908, 0 } },
+ { "⋊", { 8906, 0 } },
+ { "▹", { 9657, 0 } },
+ { "⊵", { 8885, 0 } },
+ { "▸", { 9656, 0 } },
+ { "⧎", { 10702, 0 } },
+ { "⥨", { 10600, 0 } },
+ { "℞", { 8478, 0 } },
+ { "ś", { 347, 0 } },
+ { "‚", { 8218, 0 } },
+ { "≻", { 8827, 0 } },
+ { "⪴", { 10932, 0 } },
+ { "⪸", { 10936, 0 } },
+ { "š", { 353, 0 } },
+ { "≽", { 8829, 0 } },
+ { "⪰", { 10928, 0 } },
+ { "ş", { 351, 0 } },
+ { "ŝ", { 349, 0 } },
+ { "⪶", { 10934, 0 } },
+ { "⪺", { 10938, 0 } },
+ { "⋩", { 8937, 0 } },
+ { "⨓", { 10771, 0 } },
+ { "≿", { 8831, 0 } },
+ { "с", { 1089, 0 } },
+ { "⋅", { 8901, 0 } },
+ { "⊡", { 8865, 0 } },
+ { "⩦", { 10854, 0 } },
+ { "⇘", { 8664, 0 } },
+ { "⤥", { 10533, 0 } },
+ { "↘", { 8600, 0 } },
+ { "↘", { 8600, 0 } },
+ { "§", { 167, 0 } },
+ { ";", { 59, 0 } },
+ { "⤩", { 10537, 0 } },
+ { "∖", { 8726, 0 } },
+ { "∖", { 8726, 0 } },
+ { "✶", { 10038, 0 } },
+ { "𝔰", { 120112, 0 } },
+ { "⌢", { 8994, 0 } },
+ { "♯", { 9839, 0 } },
+ { "щ", { 1097, 0 } },
+ { "ш", { 1096, 0 } },
+ { "∣", { 8739, 0 } },
+ { "∥", { 8741, 0 } },
+ { "­", { 173, 0 } },
+ { "σ", { 963, 0 } },
+ { "ς", { 962, 0 } },
+ { "ς", { 962, 0 } },
+ { "∼", { 8764, 0 } },
+ { "⩪", { 10858, 0 } },
+ { "≃", { 8771, 0 } },
+ { "≃", { 8771, 0 } },
+ { "⪞", { 10910, 0 } },
+ { "⪠", { 10912, 0 } },
+ { "⪝", { 10909, 0 } },
+ { "⪟", { 10911, 0 } },
+ { "≆", { 8774, 0 } },
+ { "⨤", { 10788, 0 } },
+ { "⥲", { 10610, 0 } },
+ { "←", { 8592, 0 } },
+ { "∖", { 8726, 0 } },
+ { "⨳", { 10803, 0 } },
+ { "⧤", { 10724, 0 } },
+ { "∣", { 8739, 0 } },
+ { "⌣", { 8995, 0 } },
+ { "⪪", { 10922, 0 } },
+ { "⪬", { 10924, 0 } },
+ { "⪬︀", { 10924, 65024 } },
+ { "ь", { 1100, 0 } },
+ { "/", { 47, 0 } },
+ { "⧄", { 10692, 0 } },
+ { "⌿", { 9023, 0 } },
+ { "𝕤", { 120164, 0 } },
+ { "♠", { 9824, 0 } },
+ { "♠", { 9824, 0 } },
+ { "∥", { 8741, 0 } },
+ { "⊓", { 8851, 0 } },
+ { "⊓︀", { 8851, 65024 } },
+ { "⊔", { 8852, 0 } },
+ { "⊔︀", { 8852, 65024 } },
+ { "⊏", { 8847, 0 } },
+ { "⊑", { 8849, 0 } },
+ { "⊏", { 8847, 0 } },
+ { "⊑", { 8849, 0 } },
+ { "⊐", { 8848, 0 } },
+ { "⊒", { 8850, 0 } },
+ { "⊐", { 8848, 0 } },
+ { "⊒", { 8850, 0 } },
+ { "□", { 9633, 0 } },
+ { "□", { 9633, 0 } },
+ { "▪", { 9642, 0 } },
+ { "▪", { 9642, 0 } },
+ { "→", { 8594, 0 } },
+ { "𝓈", { 120008, 0 } },
+ { "∖", { 8726, 0 } },
+ { "⌣", { 8995, 0 } },
+ { "⋆", { 8902, 0 } },
+ { "☆", { 9734, 0 } },
+ { "★", { 9733, 0 } },
+ { "ϵ", { 1013, 0 } },
+ { "ϕ", { 981, 0 } },
+ { "¯", { 175, 0 } },
+ { "⊂", { 8834, 0 } },
+ { "⫅", { 10949, 0 } },
+ { "⪽", { 10941, 0 } },
+ { "⊆", { 8838, 0 } },
+ { "⫃", { 10947, 0 } },
+ { "⫁", { 10945, 0 } },
+ { "⫋", { 10955, 0 } },
+ { "⊊", { 8842, 0 } },
+ { "⪿", { 10943, 0 } },
+ { "⥹", { 10617, 0 } },
+ { "⊂", { 8834, 0 } },
+ { "⊆", { 8838, 0 } },
+ { "⫅", { 10949, 0 } },
+ { "⊊", { 8842, 0 } },
+ { "⫋", { 10955, 0 } },
+ { "⫇", { 10951, 0 } },
+ { "⫕", { 10965, 0 } },
+ { "⫓", { 10963, 0 } },
+ { "≻", { 8827, 0 } },
+ { "⪸", { 10936, 0 } },
+ { "≽", { 8829, 0 } },
+ { "⪰", { 10928, 0 } },
+ { "⪺", { 10938, 0 } },
+ { "⪶", { 10934, 0 } },
+ { "⋩", { 8937, 0 } },
+ { "≿", { 8831, 0 } },
+ { "∑", { 8721, 0 } },
+ { "♪", { 9834, 0 } },
+ { "¹", { 185, 0 } },
+ { "¹", { 185, 0 } },
+ { "²", { 178, 0 } },
+ { "²", { 178, 0 } },
+ { "³", { 179, 0 } },
+ { "³", { 179, 0 } },
+ { "⊃", { 8835, 0 } },
+ { "⫆", { 10950, 0 } },
+ { "⪾", { 10942, 0 } },
+ { "⫘", { 10968, 0 } },
+ { "⊇", { 8839, 0 } },
+ { "⫄", { 10948, 0 } },
+ { "⟉", { 10185, 0 } },
+ { "⫗", { 10967, 0 } },
+ { "⥻", { 10619, 0 } },
+ { "⫂", { 10946, 0 } },
+ { "⫌", { 10956, 0 } },
+ { "⊋", { 8843, 0 } },
+ { "⫀", { 10944, 0 } },
+ { "⊃", { 8835, 0 } },
+ { "⊇", { 8839, 0 } },
+ { "⫆", { 10950, 0 } },
+ { "⊋", { 8843, 0 } },
+ { "⫌", { 10956, 0 } },
+ { "⫈", { 10952, 0 } },
+ { "⫔", { 10964, 0 } },
+ { "⫖", { 10966, 0 } },
+ { "⇙", { 8665, 0 } },
+ { "⤦", { 10534, 0 } },
+ { "↙", { 8601, 0 } },
+ { "↙", { 8601, 0 } },
+ { "⤪", { 10538, 0 } },
+ { "ß", { 223, 0 } },
+ { "⌖", { 8982, 0 } },
+ { "τ", { 964, 0 } },
+ { "⎴", { 9140, 0 } },
+ { "ť", { 357, 0 } },
+ { "ţ", { 355, 0 } },
+ { "т", { 1090, 0 } },
+ { "⃛", { 8411, 0 } },
+ { "⌕", { 8981, 0 } },
+ { "𝔱", { 120113, 0 } },
+ { "∴", { 8756, 0 } },
+ { "∴", { 8756, 0 } },
+ { "θ", { 952, 0 } },
+ { "ϑ", { 977, 0 } },
+ { "ϑ", { 977, 0 } },
+ { "≈", { 8776, 0 } },
+ { "∼", { 8764, 0 } },
+ { " ", { 8201, 0 } },
+ { "≈", { 8776, 0 } },
+ { "∼", { 8764, 0 } },
+ { "þ", { 254, 0 } },
+ { "˜", { 732, 0 } },
+ { "×", { 215, 0 } },
+ { "⊠", { 8864, 0 } },
+ { "⨱", { 10801, 0 } },
+ { "⨰", { 10800, 0 } },
+ { "∭", { 8749, 0 } },
+ { "⤨", { 10536, 0 } },
+ { "⊤", { 8868, 0 } },
+ { "⌶", { 9014, 0 } },
+ { "⫱", { 10993, 0 } },
+ { "𝕥", { 120165, 0 } },
+ { "⫚", { 10970, 0 } },
+ { "⤩", { 10537, 0 } },
+ { "‴", { 8244, 0 } },
+ { "™", { 8482, 0 } },
+ { "▵", { 9653, 0 } },
+ { "▿", { 9663, 0 } },
+ { "◃", { 9667, 0 } },
+ { "⊴", { 8884, 0 } },
+ { "≜", { 8796, 0 } },
+ { "▹", { 9657, 0 } },
+ { "⊵", { 8885, 0 } },
+ { "◬", { 9708, 0 } },
+ { "≜", { 8796, 0 } },
+ { "⨺", { 10810, 0 } },
+ { "⨹", { 10809, 0 } },
+ { "⧍", { 10701, 0 } },
+ { "⨻", { 10811, 0 } },
+ { "⏢", { 9186, 0 } },
+ { "𝓉", { 120009, 0 } },
+ { "ц", { 1094, 0 } },
+ { "ћ", { 1115, 0 } },
+ { "ŧ", { 359, 0 } },
+ { "≬", { 8812, 0 } },
+ { "↞", { 8606, 0 } },
+ { "↠", { 8608, 0 } },
+ { "⇑", { 8657, 0 } },
+ { "⥣", { 10595, 0 } },
+ { "ú", { 250, 0 } },
+ { "↑", { 8593, 0 } },
+ { "ў", { 1118, 0 } },
+ { "ŭ", { 365, 0 } },
+ { "û", { 251, 0 } },
+ { "у", { 1091, 0 } },
+ { "⇅", { 8645, 0 } },
+ { "ű", { 369, 0 } },
+ { "⥮", { 10606, 0 } },
+ { "⥾", { 10622, 0 } },
+ { "𝔲", { 120114, 0 } },
+ { "ù", { 249, 0 } },
+ { "↿", { 8639, 0 } },
+ { "↾", { 8638, 0 } },
+ { "▀", { 9600, 0 } },
+ { "⌜", { 8988, 0 } },
+ { "⌜", { 8988, 0 } },
+ { "⌏", { 8975, 0 } },
+ { "◸", { 9720, 0 } },
+ { "ū", { 363, 0 } },
+ { "¨", { 168, 0 } },
+ { "ų", { 371, 0 } },
+ { "𝕦", { 120166, 0 } },
+ { "↑", { 8593, 0 } },
+ { "↕", { 8597, 0 } },
+ { "↿", { 8639, 0 } },
+ { "↾", { 8638, 0 } },
+ { "⊎", { 8846, 0 } },
+ { "υ", { 965, 0 } },
+ { "ϒ", { 978, 0 } },
+ { "υ", { 965, 0 } },
+ { "⇈", { 8648, 0 } },
+ { "⌝", { 8989, 0 } },
+ { "⌝", { 8989, 0 } },
+ { "⌎", { 8974, 0 } },
+ { "ů", { 367, 0 } },
+ { "◹", { 9721, 0 } },
+ { "𝓊", { 120010, 0 } },
+ { "⋰", { 8944, 0 } },
+ { "ũ", { 361, 0 } },
+ { "▵", { 9653, 0 } },
+ { "▴", { 9652, 0 } },
+ { "⇈", { 8648, 0 } },
+ { "ü", { 252, 0 } },
+ { "⦧", { 10663, 0 } },
+ { "⇕", { 8661, 0 } },
+ { "⫨", { 10984, 0 } },
+ { "⫩", { 10985, 0 } },
+ { "⊨", { 8872, 0 } },
+ { "⦜", { 10652, 0 } },
+ { "ϵ", { 1013, 0 } },
+ { "ϰ", { 1008, 0 } },
+ { "∅", { 8709, 0 } },
+ { "ϕ", { 981, 0 } },
+ { "ϖ", { 982, 0 } },
+ { "∝", { 8733, 0 } },
+ { "↕", { 8597, 0 } },
+ { "ϱ", { 1009, 0 } },
+ { "ς", { 962, 0 } },
+ { "⊊︀", { 8842, 65024 } },
+ { "⫋︀", { 10955, 65024 } },
+ { "⊋︀", { 8843, 65024 } },
+ { "⫌︀", { 10956, 65024 } },
+ { "ϑ", { 977, 0 } },
+ { "⊲", { 8882, 0 } },
+ { "⊳", { 8883, 0 } },
+ { "в", { 1074, 0 } },
+ { "⊢", { 8866, 0 } },
+ { "∨", { 8744, 0 } },
+ { "⊻", { 8891, 0 } },
+ { "≚", { 8794, 0 } },
+ { "⋮", { 8942, 0 } },
+ { "|", { 124, 0 } },
+ { "|", { 124, 0 } },
+ { "𝔳", { 120115, 0 } },
+ { "⊲", { 8882, 0 } },
+ { "⊂⃒", { 8834, 8402 } },
+ { "⊃⃒", { 8835, 8402 } },
+ { "𝕧", { 120167, 0 } },
+ { "∝", { 8733, 0 } },
+ { "⊳", { 8883, 0 } },
+ { "𝓋", { 120011, 0 } },
+ { "⫋︀", { 10955, 65024 } },
+ { "⊊︀", { 8842, 65024 } },
+ { "⫌︀", { 10956, 65024 } },
+ { "⊋︀", { 8843, 65024 } },
+ { "⦚", { 10650, 0 } },
+ { "ŵ", { 373, 0 } },
+ { "⩟", { 10847, 0 } },
+ { "∧", { 8743, 0 } },
+ { "≙", { 8793, 0 } },
+ { "℘", { 8472, 0 } },
+ { "𝔴", { 120116, 0 } },
+ { "𝕨", { 120168, 0 } },
+ { "℘", { 8472, 0 } },
+ { "≀", { 8768, 0 } },
+ { "≀", { 8768, 0 } },
+ { "𝓌", { 120012, 0 } },
+ { "⋂", { 8898, 0 } },
+ { "◯", { 9711, 0 } },
+ { "⋃", { 8899, 0 } },
+ { "▽", { 9661, 0 } },
+ { "𝔵", { 120117, 0 } },
+ { "⟺", { 10234, 0 } },
+ { "⟷", { 10231, 0 } },
+ { "ξ", { 958, 0 } },
+ { "⟸", { 10232, 0 } },
+ { "⟵", { 10229, 0 } },
+ { "⟼", { 10236, 0 } },
+ { "⋻", { 8955, 0 } },
+ { "⨀", { 10752, 0 } },
+ { "𝕩", { 120169, 0 } },
+ { "⨁", { 10753, 0 } },
+ { "⨂", { 10754, 0 } },
+ { "⟹", { 10233, 0 } },
+ { "⟶", { 10230, 0 } },
+ { "𝓍", { 120013, 0 } },
+ { "⨆", { 10758, 0 } },
+ { "⨄", { 10756, 0 } },
+ { "△", { 9651, 0 } },
+ { "⋁", { 8897, 0 } },
+ { "⋀", { 8896, 0 } },
+ { "ý", { 253, 0 } },
+ { "я", { 1103, 0 } },
+ { "ŷ", { 375, 0 } },
+ { "ы", { 1099, 0 } },
+ { "¥", { 165, 0 } },
+ { "𝔶", { 120118, 0 } },
+ { "ї", { 1111, 0 } },
+ { "𝕪", { 120170, 0 } },
+ { "𝓎", { 120014, 0 } },
+ { "ю", { 1102, 0 } },
+ { "ÿ", { 255, 0 } },
+ { "ź", { 378, 0 } },
+ { "ž", { 382, 0 } },
+ { "з", { 1079, 0 } },
+ { "ż", { 380, 0 } },
+ { "ℨ", { 8488, 0 } },
+ { "ζ", { 950, 0 } },
+ { "𝔷", { 120119, 0 } },
+ { "ж", { 1078, 0 } },
+ { "⇝", { 8669, 0 } },
+ { "𝕫", { 120171, 0 } },
+ { "𝓏", { 120015, 0 } },
+ { "‍", { 8205, 0 } },
+ { "‌", { 8204, 0 } }
+};
+
+
+struct entity_key {
+ const char* name;
+ size_t name_size;
+};
+
+static int
+entity_cmp(const void* p_key, const void* p_entity)
+{
+ struct entity_key* key = (struct entity_key*) p_key;
+ struct entity* ent = (struct entity*) p_entity;
+
+ return strncmp(key->name, ent->name, key->name_size);
+}
+
+const struct entity*
+entity_lookup(const char* name, size_t name_size)
+{
+ struct entity_key key = { name, name_size };
+
+ return bsearch(&key,
+ entity_table,
+ sizeof(entity_table) / sizeof(entity_table[0]),
+ sizeof(struct entity),
+ entity_cmp);
+}
diff --git a/entity.h b/entity.h
@@ -0,0 +1,42 @@
+/*
+ * MD4C: Markdown parser for C
+ * (http://github.com/mity/md4c)
+ *
+ * Copyright (c) 2016-2017 Martin Mitas
+ *
+ * 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.
+ */
+
+#ifndef MD2HTML_ENTITY_H
+#define MD2HTML_ENTITY_H
+
+#include <stdlib.h>
+
+
+/* Most entities are formed by single Unicode codepoint, few by two codepoints.
+ * Single-codepoint entities have codepoints[1] set to zero. */
+struct entity {
+ const char* name;
+ unsigned codepoints[2];
+};
+
+const struct entity* entity_lookup(const char* name, size_t name_size);
+
+
+#endif /* MD2HTML_ENTITY_H */
diff --git a/md2html.c b/md2html.c
@@ -0,0 +1,350 @@
+/*
+ * MD4C: Markdown parser for C
+ * (http://github.com/mity/md4c)
+ *
+ * Copyright (c) 2016-2017 Martin Mitas
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "render_html.h"
+#include "cmdline.h"
+
+
+
+/* Global options. */
+static unsigned parser_flags = 0;
+static unsigned renderer_flags = MD_RENDER_FLAG_DEBUG;
+static int want_fullhtml = 0;
+static int want_stat = 0;
+
+
+/*********************************
+ *** Simple grow-able buffer ***
+ *********************************/
+
+/* We render to a memory buffer instead of directly outputting the rendered
+ * documents, as this allows using this utility for evaluating performance
+ * of MD4C (--stat option). This allows us to measure just time of the parser,
+ * without the I/O.
+ */
+
+struct membuffer {
+ char* data;
+ MD_SIZE asize;
+ MD_SIZE size;
+};
+
+static void
+membuf_init(struct membuffer* buf, MD_SIZE new_asize)
+{
+ buf->size = 0;
+ buf->asize = new_asize;
+ buf->data = malloc(buf->asize);
+ if(buf->data == NULL) {
+ fprintf(stderr, "membuf_init: malloc() failed.");
+ exit(1);
+ }
+}
+
+static void
+membuf_fini(struct membuffer* buf)
+{
+ if(buf->data)
+ free(buf->data);
+}
+
+static void
+membuf_grow(struct membuffer* buf, MD_SIZE new_asize)
+{
+ buf->data = realloc(buf->data, new_asize);
+ if(buf->data == NULL) {
+ fprintf(stderr, "membuf_grow: realloc() failed.");
+ exit(1);
+ }
+ buf->asize = new_asize;
+}
+
+static void
+membuf_append(struct membuffer* buf, const char* data, MD_SIZE size)
+{
+ if(buf->asize < buf->size + size)
+ membuf_grow(buf, (buf->size + size) * 2);
+ memcpy(buf->data + buf->size, data, size);
+ buf->size += size;
+}
+
+
+/**********************
+ *** Main program ***
+ **********************/
+
+static void
+process_output(const MD_CHAR* text, MD_SIZE size, void* userdata)
+{
+ membuf_append((struct membuffer*) userdata, text, size);
+}
+
+static int
+process_file(FILE* in, FILE* out)
+{
+ MD_SIZE n;
+ struct membuffer buf_in = {0};
+ struct membuffer buf_out = {0};
+ int ret = -1;
+ clock_t t0, t1;
+
+ membuf_init(&buf_in, 32 * 1024);
+
+ /* Read the input file into a buffer. */
+ while(1) {
+ if(buf_in.size >= buf_in.asize)
+ membuf_grow(&buf_in, 2 * buf_in.asize);
+
+ n = fread(buf_in.data + buf_in.size, 1, buf_in.asize - buf_in.size, in);
+ if(n == 0)
+ break;
+ buf_in.size += n;
+ }
+
+ /* Input size is good estimation of output size. Add some more reserve to
+ * deal with the HTML header/footer and tags. */
+ membuf_init(&buf_out, buf_in.size + buf_in.size/8 + 64);
+
+ /* Parse the document. This shall call our callbacks provided via the
+ * md_renderer_t structure. */
+ t0 = clock();
+
+ ret = md_render_html(buf_in.data, buf_in.size, process_output,
+ (void*) &buf_out, parser_flags, renderer_flags);
+
+ t1 = clock();
+ if(ret != 0) {
+ fprintf(stderr, "Parsing failed.\n");
+ goto out;
+ }
+
+ /* Write down the document in the HTML format. */
+ if(want_fullhtml) {
+ fprintf(out, "<html>\n");
+ fprintf(out, "<head>\n");
+ fprintf(out, "<title></title>\n");
+ fprintf(out, "<meta name=\"generator\" content=\"md2html\">\n");
+ fprintf(out, "</head>\n");
+ fprintf(out, "<body>\n");
+ }
+
+ fwrite(buf_out.data, 1, buf_out.size, out);
+
+ if(want_fullhtml) {
+ fprintf(out, "</body>\n");
+ fprintf(out, "</html>\n");
+ }
+
+ if(want_stat) {
+ if(t0 != (clock_t)-1 && t1 != (clock_t)-1) {
+ double elapsed = (double)(t1 - t0) / CLOCKS_PER_SEC;
+ if (elapsed < 1)
+ fprintf(stderr, "Time spent on parsing: %7.2f ms.\n", elapsed*1e3);
+ else
+ fprintf(stderr, "Time spent on parsing: %6.3f s.\n", elapsed);
+ }
+ }
+
+ /* Success if we have reached here. */
+ ret = 0;
+
+out:
+ membuf_fini(&buf_in);
+ membuf_fini(&buf_out);
+
+ return ret;
+}
+
+
+#define OPTION_ARG_NONE 0
+#define OPTION_ARG_REQUIRED 1
+#define OPTION_ARG_OPTIONAL 2
+
+static const option cmdline_options[] = {
+ { "output", 'o', 'o', OPTION_ARG_REQUIRED },
+ { "full-html", 'f', 'f', OPTION_ARG_NONE },
+ { "stat", 's', 's', OPTION_ARG_NONE },
+ { "help", 'h', 'h', OPTION_ARG_NONE },
+ { "version", 'v', 'v', OPTION_ARG_NONE },
+ { "commonmark", 0, 'c', OPTION_ARG_NONE },
+ { "github", 0, 'g', OPTION_ARG_NONE },
+ { "fverbatim-entities", 0, 'E', OPTION_ARG_NONE },
+ { "fpermissive-atx-headers", 0, 'A', OPTION_ARG_NONE },
+ { "fpermissive-url-autolinks", 0, 'U', OPTION_ARG_NONE },
+ { "fpermissive-www-autolinks", 0, '.', OPTION_ARG_NONE },
+ { "fpermissive-email-autolinks", 0, '@', OPTION_ARG_NONE },
+ { "fpermissive-autolinks", 0, 'V', OPTION_ARG_NONE },
+ { "fno-indented-code", 0, 'I', OPTION_ARG_NONE },
+ { "fno-html-blocks", 0, 'F', OPTION_ARG_NONE },
+ { "fno-html-spans", 0, 'G', OPTION_ARG_NONE },
+ { "fno-html", 0, 'H', OPTION_ARG_NONE },
+ { "fcollapse-whitespace", 0, 'W', OPTION_ARG_NONE },
+ { "ftables", 0, 'T', OPTION_ARG_NONE },
+ { "fstrikethrough", 0, 'S', OPTION_ARG_NONE },
+ { 0 }
+};
+
+static void
+usage(void)
+{
+ printf(
+ "Usage: md2html [OPTION]... [FILE]\n"
+ "Convert input FILE (or standard input) in Markdown format to HTML.\n"
+ "\n"
+ "General options:\n"
+ " -o --output=FILE Output file (default is standard output)\n"
+ " -f, --full-html Generate full HTML document, including header\n"
+ " -s, --stat Measure time of input parsing\n"
+ " -h, --help Display this help and exit\n"
+ " -v, --version Display version and exit\n"
+ "\n"
+ "Markdown dialect options:\n"
+ "(note these are equivalent to some combinations of flags below)\n"
+ " --commonmark CommonMark (this is default)\n"
+ " --github Github Flavored Markdown\n"
+ "\n"
+ "Markdown extension options:\n"
+ " --fcollapse-whitespace\n"
+ " Collapse non-trivial whitespace\n"
+ " --fverbatim-entities\n"
+ " Do not translate entities\n"
+ " --fpermissive-atx-headers\n"
+ " Allow ATX headers without delimiting space\n"
+ " --fpermissive-url-autolinks\n"
+ " Allow URL autolinks without '<', '>'\n"
+ " --fpermissive-www-autolinks\n"
+ " Allow WWW autolinks without any scheme (e.g. 'www.example.com')\n"
+ " --fpermissive-email-autolinks \n"
+ " Allow e-mail autolinks without '<', '>' and 'mailto:'\n"
+ " --fpermissive-autolinks\n"
+ " Same as --fpermissive-url-autolinks --fpermissive-www-autolinks\n"
+ " --fpermissive-email-autolinks\n"
+ " --fno-indented-code\n"
+ " Disable indented code blocks\n"
+ " --fno-html-blocks\n"
+ " Disable raw HTML blocks\n"
+ " --fno-html-spans\n"
+ " Disable raw HTML spans\n"
+ " --fno-html Same as --fno-html-blocks --fno-html-spans\n"
+ " --ftables Enable tables\n"
+ " --fstrikethrough Enable strikethrough spans\n"
+ );
+}
+
+static void
+version(void)
+{
+ printf("%d.%d.%d\n", MD_VERSION_MAJOR, MD_VERSION_MINOR, MD_VERSION_RELEASE);
+}
+
+static const char* input_path = NULL;
+static const char* output_path = NULL;
+
+static int
+cmdline_callback(int opt, char const* value, void* data)
+{
+ switch(opt) {
+ case 0:
+ if(input_path) {
+ fprintf(stderr, "Too many arguments. Only one input file can be specified.\n");
+ fprintf(stderr, "Use --help for more info.\n");
+ exit(1);
+ }
+ input_path = value;
+ break;
+
+ case 'o': output_path = value; break;
+ case 'f': want_fullhtml = 1; break;
+ case 's': want_stat = 1; break;
+ case 'h': usage(); exit(0); break;
+ case 'v': version(); exit(0); break;
+
+ case 'c': parser_flags = MD_DIALECT_COMMONMARK; break;
+ case 'g': parser_flags = MD_DIALECT_GITHUB; break;
+
+ case 'E': renderer_flags |= MD_RENDER_FLAG_VERBATIM_ENTITIES; break;
+ case 'A': parser_flags |= MD_FLAG_PERMISSIVEATXHEADERS; break;
+ case 'I': parser_flags |= MD_FLAG_NOINDENTEDCODEBLOCKS; break;
+ case 'F': parser_flags |= MD_FLAG_NOHTMLBLOCKS; break;
+ case 'G': parser_flags |= MD_FLAG_NOHTMLSPANS; break;
+ case 'H': parser_flags |= MD_FLAG_NOHTML; break;
+ case 'W': parser_flags |= MD_FLAG_COLLAPSEWHITESPACE; break;
+ case 'U': parser_flags |= MD_FLAG_PERMISSIVEURLAUTOLINKS; break;
+ case '.': parser_flags |= MD_FLAG_PERMISSIVEWWWAUTOLINKS; break;
+ case '@': parser_flags |= MD_FLAG_PERMISSIVEEMAILAUTOLINKS; break;
+ case 'V': parser_flags |= MD_FLAG_PERMISSIVEAUTOLINKS; break;
+ case 'T': parser_flags |= MD_FLAG_TABLES; break;
+ case 'S': parser_flags |= MD_FLAG_STRIKETHROUGH; break;
+
+ default:
+ fprintf(stderr, "Illegal option: %s\n", value);
+ fprintf(stderr, "Use --help for more info.\n");
+ exit(1);
+ break;
+ }
+
+ return 0;
+}
+
+int
+main(int argc, char** argv)
+{
+ FILE* in = stdin;
+ FILE* out = stdout;
+ int ret = 0;
+
+ if(readoptions(cmdline_options, argc, argv, cmdline_callback, NULL) < 0) {
+ usage();
+ exit(1);
+ }
+
+ if(input_path != NULL && strcmp(input_path, "-") != 0) {
+ in = fopen(input_path, "rb");
+ if(in == NULL) {
+ fprintf(stderr, "Cannot open %s.\n", input_path);
+ exit(1);
+ }
+ }
+ if(output_path != NULL && strcmp(output_path, "-") != 0) {
+ out = fopen(output_path, "wt");
+ if(out == NULL) {
+ fprintf(stderr, "Cannot open %s.\n", input_path);
+ exit(1);
+ }
+ }
+
+ ret = process_file(in, out);
+ if(in != stdin)
+ fclose(in);
+ if(out != stdout)
+ fclose(out);
+
+ return ret;
+}
diff --git a/package.yml b/package.yml
@@ -0,0 +1,30 @@
+---
+ name: md2html
+ version: 0.0.1
+ description: "markdown to html converter"
+ bin: ./md2html.c
+ #cflags: -DA -ggdb -std=gnu11 -fPIC -pipe
+ #lflags: -lpcre
+ repository:
+ type: git
+ url: git+https://noulin.net/git/md2html.git
+ keywords:
+ #- utility
+ - command
+ author: Remy
+ license: MIT
+ homepage: https://noulin.net/md2html/log.html
+ #compileHelp: # text displayed when there is a compilation error
+ dependencies:
+ md4c:
+ # Test configuration:
+ #testBin: ./testMd2html.c
+ #testCflags: -ggdb -std=gnu11 -fPIC -pipe -fprofile-arcs -ftest-coverage -Wall -Wextra
+ #testLflags: -lcheck_pic -lrt -lm -lsubunit -fprofile-arcs -ftest-coverage -rdynamic
+ # Memcheck configuration:
+ #memcheckBin: ./memcheckMd2html.c
+ #memcheckCmd: valgrind --leak-check=full --show-leak-kinds=all
+ #memcheckCflags: -ggdb -std=gnu11 -fPIC -pipe
+ #memcheckLflags: -rdynamic
+ #documentationCmd: # command for generating the documentation with spm doc
+ private: false # true for private package
diff --git a/render_html.c b/render_html.c
@@ -0,0 +1,490 @@
+/*
+ * MD4C: Markdown parser for C
+ * (http://github.com/mity/md4c)
+ *
+ * Copyright (c) 2016-2017 Martin Mitas
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "render_html.h"
+#include "entity.h"
+
+
+#ifdef _MSC_VER
+ /* MSVC does not understand "inline" when building as pure C (not C++).
+ * However it understands "__inline" */
+ #ifndef __cplusplus
+ #define inline __inline
+ #endif
+#endif
+
+#ifdef _WIN32
+ #define snprintf _snprintf
+#endif
+
+
+
+typedef struct MD_RENDER_HTML_tag MD_RENDER_HTML;
+struct MD_RENDER_HTML_tag {
+ void (*process_output)(const MD_CHAR*, MD_SIZE, void*);
+ void* userdata;
+ unsigned flags;
+ int image_nesting_level;
+};
+
+
+/*****************************************
+ *** HTML rendering helper functions ***
+ *****************************************/
+
+#define ISDIGIT(ch) ('0' <= (ch) && (ch) <= '9')
+#define ISLOWER(ch) ('a' <= (ch) && (ch) <= 'z')
+#define ISUPPER(ch) ('A' <= (ch) && (ch) <= 'Z')
+#define ISALNUM(ch) (ISLOWER(ch) || ISUPPER(ch) || ISDIGIT(ch))
+
+
+static inline void
+render_text(MD_RENDER_HTML* r, const MD_CHAR* text, MD_SIZE size)
+{
+ r->process_output(text, size, r->userdata);
+}
+
+#define RENDER_LITERAL(r, literal) render_text((r), (literal), strlen(literal))
+
+
+static void
+render_html_escaped(MD_RENDER_HTML* r, const MD_CHAR* data, MD_SIZE size)
+{
+ MD_OFFSET beg = 0;
+ MD_OFFSET off = 0;
+
+ /* Some characters need to be escaped in normal HTML text. */
+ #define HTML_NEED_ESCAPE(ch) \
+ ((ch) == '&' || (ch) == '<' || (ch) == '>' || (ch) == '"')
+
+ while(1) {
+ while(off < size && !HTML_NEED_ESCAPE(data[off]))
+ off++;
+ if(off > beg)
+ render_text(r, data + beg, off - beg);
+
+ if(off < size) {
+ switch(data[off]) {
+ case '&': RENDER_LITERAL(r, "&"); break;
+ case '<': RENDER_LITERAL(r, "<"); break;
+ case '>': RENDER_LITERAL(r, ">"); break;
+ case '"': RENDER_LITERAL(r, """); break;
+ }
+ off++;
+ } else {
+ break;
+ }
+ beg = off;
+ }
+}
+
+static void
+render_url_escaped(MD_RENDER_HTML* r, const MD_CHAR* data, MD_SIZE size)
+{
+ static const MD_CHAR hex_chars[] = "0123456789ABCDEF";
+ MD_OFFSET beg = 0;
+ MD_OFFSET off = 0;
+
+ #define URL_NEED_ESCAPE(ch) \
+ (!ISALNUM(ch) && strchr("-_.+!*'(),%#@?=;:/,+$", ch) == NULL)
+
+ while(1) {
+ while(off < size && !URL_NEED_ESCAPE(data[off]))
+ off++;
+ if(off > beg)
+ render_text(r, data + beg, off - beg);
+
+ if(off < size) {
+ char hex[3];
+
+ switch(data[off]) {
+ case '&': RENDER_LITERAL(r, "&"); break;
+ case '\'': RENDER_LITERAL(r, "'"); break;
+ default:
+ hex[0] = '%';
+ hex[1] = hex_chars[((unsigned)data[off] >> 4) & 0xf];
+ hex[2] = hex_chars[((unsigned)data[off] >> 0) & 0xf];
+ render_text(r, hex, 3);
+ break;
+ }
+ off++;
+ } else {
+ break;
+ }
+
+ beg = off;
+ }
+}
+
+static unsigned
+hex_val(char ch)
+{
+ if('0' <= ch && ch <= '9')
+ return ch - '0';
+ if('A' <= ch && ch <= 'Z')
+ return ch - 'A' + 10;
+ else
+ return ch - 'a' + 10;
+}
+
+static void
+render_utf8_codepoint(MD_RENDER_HTML* r, unsigned codepoint,
+ void (*fn_append)(MD_RENDER_HTML*, const MD_CHAR*, MD_SIZE))
+{
+ static const MD_CHAR utf8_replacement_char[] = { 0xef, 0xbf, 0xbd };
+
+ unsigned char utf8[4];
+ size_t n;
+
+ if(codepoint <= 0x7f) {
+ n = 1;
+ utf8[0] = codepoint;
+ } else if(codepoint <= 0x7ff) {
+ n = 2;
+ utf8[0] = 0xc0 | ((codepoint >> 6) & 0x1f);
+ utf8[1] = 0x80 + ((codepoint >> 0) & 0x3f);
+ } else if(codepoint <= 0xffff) {
+ n = 3;
+ utf8[0] = 0xe0 | ((codepoint >> 12) & 0xf);
+ utf8[1] = 0x80 + ((codepoint >> 6) & 0x3f);
+ utf8[2] = 0x80 + ((codepoint >> 0) & 0x3f);
+ } else {
+ n = 4;
+ utf8[0] = 0xf0 | ((codepoint >> 18) & 0x7);
+ utf8[1] = 0x80 + ((codepoint >> 12) & 0x3f);
+ utf8[2] = 0x80 + ((codepoint >> 6) & 0x3f);
+ utf8[3] = 0x80 + ((codepoint >> 0) & 0x3f);
+ }
+
+ if(0 < codepoint && codepoint <= 0x10ffff)
+ fn_append(r, (char*)utf8, n);
+ else
+ fn_append(r, utf8_replacement_char, 3);
+}
+
+/* Translate entity to its UTF-8 equivalent, or output the verbatim one
+ * if such entity is unknown (or if the translation is disabled). */
+static void
+render_entity(MD_RENDER_HTML* r, const MD_CHAR* text, MD_SIZE size,
+ void (*fn_append)(MD_RENDER_HTML*, const MD_CHAR*, MD_SIZE))
+{
+ if(r->flags & MD_RENDER_FLAG_VERBATIM_ENTITIES) {
+ fn_append(r, text, size);
+ return;
+ }
+
+ /* We assume UTF-8 output is what is desired. */
+ if(size > 3 && text[1] == '#') {
+ unsigned codepoint = 0;
+
+ if(text[2] == 'x' || text[2] == 'X') {
+ /* Hexadecimal entity (e.g. "�")). */
+ MD_SIZE i;
+ for(i = 3; i < size-1; i++)
+ codepoint = 16 * codepoint + hex_val(text[i]);
+ } else {
+ /* Decimal entity (e.g. "&1234;") */
+ MD_SIZE i;
+ for(i = 2; i < size-1; i++)
+ codepoint = 10 * codepoint + (text[i] - '0');
+ }
+
+ render_utf8_codepoint(r, codepoint, fn_append);
+ return;
+ } else {
+ /* Named entity (e.g. " "). */
+ const struct entity* ent;
+
+ ent = entity_lookup(text, size);
+ if(ent != NULL) {
+ render_utf8_codepoint(r, ent->codepoints[0], fn_append);
+ if(ent->codepoints[1])
+ render_utf8_codepoint(r, ent->codepoints[1], fn_append);
+ return;
+ }
+ }
+
+ fn_append(r, text, size);
+}
+
+static void
+render_attribute(MD_RENDER_HTML* r, const MD_ATTRIBUTE* attr,
+ void (*fn_append)(MD_RENDER_HTML*, const MD_CHAR*, MD_SIZE))
+{
+ int i;
+
+ for(i = 0; attr->substr_offsets[i] < attr->size; i++) {
+ MD_TEXTTYPE type = attr->substr_types[i];
+ MD_OFFSET off = attr->substr_offsets[i];
+ MD_SIZE size = attr->substr_offsets[i+1] - off;
+ const MD_CHAR* text = attr->text + off;
+
+ switch(type) {
+ case MD_TEXT_NULLCHAR: render_utf8_codepoint(r, 0x0000, render_text); break;
+ case MD_TEXT_ENTITY: render_entity(r, text, size, fn_append); break;
+ default: fn_append(r, text, size); break;
+ }
+ }
+}
+
+
+static void
+render_open_ol_block(MD_RENDER_HTML* r, const MD_BLOCK_OL_DETAIL* det)
+{
+ char buf[64];
+
+ if(det->start == 1) {
+ RENDER_LITERAL(r, "<ol>\n");
+ return;
+ }
+
+ snprintf(buf, sizeof(buf), "<ol start=\"%u\">\n", det->start);
+ RENDER_LITERAL(r, buf);
+}
+
+static void
+render_open_code_block(MD_RENDER_HTML* r, const MD_BLOCK_CODE_DETAIL* det)
+{
+ RENDER_LITERAL(r, "<pre><code");
+
+ /* If known, output the HTML 5 attribute class="language-LANGNAME". */
+ if(det->lang.text != NULL) {
+ RENDER_LITERAL(r, " class=\"language-");
+ render_attribute(r, &det->lang, render_html_escaped);
+ RENDER_LITERAL(r, "\"");
+ }
+
+ RENDER_LITERAL(r, ">");
+}
+
+static void
+render_open_td_block(MD_RENDER_HTML* r, const MD_CHAR* cell_type, const MD_BLOCK_TD_DETAIL* det)
+{
+ RENDER_LITERAL(r, "<");
+ RENDER_LITERAL(r, cell_type);
+
+ switch(det->align) {
+ case MD_ALIGN_LEFT: RENDER_LITERAL(r, " align=\"left\">"); break;
+ case MD_ALIGN_CENTER: RENDER_LITERAL(r, " align=\"center\">"); break;
+ case MD_ALIGN_RIGHT: RENDER_LITERAL(r, " align=\"right\">"); break;
+ default: RENDER_LITERAL(r, ">"); break;
+ }
+}
+
+static void
+render_open_a_span(MD_RENDER_HTML* r, const MD_SPAN_A_DETAIL* det)
+{
+ RENDER_LITERAL(r, "<a href=\"");
+ render_attribute(r, &det->href, render_url_escaped);
+
+ if(det->title.text != NULL) {
+ RENDER_LITERAL(r, "\" title=\"");
+ render_attribute(r, &det->title, render_html_escaped);
+ }
+
+ RENDER_LITERAL(r, "\">");
+}
+
+static void
+render_open_img_span(MD_RENDER_HTML* r, const MD_SPAN_IMG_DETAIL* det)
+{
+ RENDER_LITERAL(r, "<img src=\"");
+ render_attribute(r, &det->src, render_url_escaped);
+
+ RENDER_LITERAL(r, "\" alt=\"");
+
+ r->image_nesting_level++;
+}
+
+static void
+render_close_img_span(MD_RENDER_HTML* r, const MD_SPAN_IMG_DETAIL* det)
+{
+ if(det->title.text != NULL) {
+ RENDER_LITERAL(r, "\" title=\"");
+ render_attribute(r, &det->title, render_html_escaped);
+ }
+
+ RENDER_LITERAL(r, "\">");
+
+ r->image_nesting_level--;
+}
+
+
+/**************************************
+ *** HTML renderer implementation ***
+ **************************************/
+
+static int
+enter_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
+{
+ static const MD_CHAR* head[6] = { "<h1>", "<h2>", "<h3>", "<h4>", "<h5>", "<h6>" };
+ MD_RENDER_HTML* r = (MD_RENDER_HTML*) userdata;
+
+ switch(type) {
+ case MD_BLOCK_DOC: /* noop */ break;
+ case MD_BLOCK_QUOTE: RENDER_LITERAL(r, "<blockquote>\n"); break;
+ case MD_BLOCK_UL: RENDER_LITERAL(r, "<ul>\n"); break;
+ case MD_BLOCK_OL: render_open_ol_block(r, (const MD_BLOCK_OL_DETAIL*)detail); break;
+ case MD_BLOCK_LI: RENDER_LITERAL(r, "<li>"); break;
+ case MD_BLOCK_HR: RENDER_LITERAL(r, "<hr>\n"); break;
+ case MD_BLOCK_H: RENDER_LITERAL(r, head[((MD_BLOCK_H_DETAIL*)detail)->level - 1]); break;
+ case MD_BLOCK_CODE: render_open_code_block(r, (const MD_BLOCK_CODE_DETAIL*) detail); break;
+ case MD_BLOCK_HTML: /* noop */ break;
+ case MD_BLOCK_P: RENDER_LITERAL(r, "<p>"); break;
+ case MD_BLOCK_TABLE: RENDER_LITERAL(r, "<table>\n"); break;
+ case MD_BLOCK_THEAD: RENDER_LITERAL(r, "<thead>\n"); break;
+ case MD_BLOCK_TBODY: RENDER_LITERAL(r, "<tbody>\n"); break;
+ case MD_BLOCK_TR: RENDER_LITERAL(r, "<tr>\n"); break;
+ case MD_BLOCK_TH: render_open_td_block(r, "th", (MD_BLOCK_TD_DETAIL*)detail); break;
+ case MD_BLOCK_TD: render_open_td_block(r, "td", (MD_BLOCK_TD_DETAIL*)detail); break;
+ }
+
+ return 0;
+}
+
+static int
+leave_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
+{
+ static const MD_CHAR* head[6] = { "</h1>\n", "</h2>\n", "</h3>\n", "</h4>\n", "</h5>\n", "</h6>\n" };
+ MD_RENDER_HTML* r = (MD_RENDER_HTML*) userdata;
+
+ switch(type) {
+ case MD_BLOCK_DOC: /*noop*/ break;
+ case MD_BLOCK_QUOTE: RENDER_LITERAL(r, "</blockquote>\n"); break;
+ case MD_BLOCK_UL: RENDER_LITERAL(r, "</ul>\n"); break;
+ case MD_BLOCK_OL: RENDER_LITERAL(r, "</ol>\n"); break;
+ case MD_BLOCK_LI: RENDER_LITERAL(r, "</li>\n"); break;
+ case MD_BLOCK_HR: /*noop*/ break;
+ case MD_BLOCK_H: RENDER_LITERAL(r, head[((MD_BLOCK_H_DETAIL*)detail)->level - 1]); break;
+ case MD_BLOCK_CODE: RENDER_LITERAL(r, "</code></pre>\n"); break;
+ case MD_BLOCK_HTML: /* noop */ break;
+ case MD_BLOCK_P: RENDER_LITERAL(r, "</p>\n"); break;
+ case MD_BLOCK_TABLE: RENDER_LITERAL(r, "</table>\n"); break;
+ case MD_BLOCK_THEAD: RENDER_LITERAL(r, "</thead>\n"); break;
+ case MD_BLOCK_TBODY: RENDER_LITERAL(r, "</tbody>\n"); break;
+ case MD_BLOCK_TR: RENDER_LITERAL(r, "</tr>\n"); break;
+ case MD_BLOCK_TH: RENDER_LITERAL(r, "</th>\n"); break;
+ case MD_BLOCK_TD: RENDER_LITERAL(r, "</td>\n"); break;
+ }
+
+ return 0;
+}
+
+static int
+enter_span_callback(MD_SPANTYPE type, void* detail, void* userdata)
+{
+ MD_RENDER_HTML* r = (MD_RENDER_HTML*) userdata;
+
+ if(r->image_nesting_level > 0) {
+ /* We are inside an image, i.e. rendering the ALT attribute of
+ * <IMG> tag. */
+ return 0;
+ }
+
+ switch(type) {
+ case MD_SPAN_EM: RENDER_LITERAL(r, "<em>"); break;
+ case MD_SPAN_STRONG: RENDER_LITERAL(r, "<strong>"); break;
+ case MD_SPAN_A: render_open_a_span(r, (MD_SPAN_A_DETAIL*) detail); break;
+ case MD_SPAN_IMG: render_open_img_span(r, (MD_SPAN_IMG_DETAIL*) detail); break;
+ case MD_SPAN_CODE: RENDER_LITERAL(r, "<code>"); break;
+ case MD_SPAN_DEL: RENDER_LITERAL(r, "<del>"); break;
+ }
+
+ return 0;
+}
+
+static int
+leave_span_callback(MD_SPANTYPE type, void* detail, void* userdata)
+{
+ MD_RENDER_HTML* r = (MD_RENDER_HTML*) userdata;
+
+ if(r->image_nesting_level > 0) {
+ /* We are inside an image, i.e. rendering the ALT attribute of
+ * <IMG> tag. */
+ if(r->image_nesting_level == 1 && type == MD_SPAN_IMG)
+ render_close_img_span(r, (MD_SPAN_IMG_DETAIL*) detail);
+ return 0;
+ }
+
+ switch(type) {
+ case MD_SPAN_EM: RENDER_LITERAL(r, "</em>"); break;
+ case MD_SPAN_STRONG: RENDER_LITERAL(r, "</strong>"); break;
+ case MD_SPAN_A: RENDER_LITERAL(r, "</a>"); break;
+ case MD_SPAN_IMG: /*noop, handled above*/ break;
+ case MD_SPAN_CODE: RENDER_LITERAL(r, "</code>"); break;
+ case MD_SPAN_DEL: RENDER_LITERAL(r, "</del>"); break;
+ }
+
+ return 0;
+}
+
+static int
+text_callback(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata)
+{
+ MD_RENDER_HTML* r = (MD_RENDER_HTML*) userdata;
+
+ switch(type) {
+ case MD_TEXT_NULLCHAR: render_utf8_codepoint(r, 0x0000, render_text); break;
+ case MD_TEXT_BR: RENDER_LITERAL(r, (r->image_nesting_level == 0 ? "<br>\n" : " ")); break;
+ case MD_TEXT_SOFTBR: RENDER_LITERAL(r, (r->image_nesting_level == 0 ? "\n" : " ")); break;
+ case MD_TEXT_HTML: render_text(r, text, size); break;
+ case MD_TEXT_ENTITY: render_entity(r, text, size, render_html_escaped); break;
+ default: render_html_escaped(r, text, size); break;
+ }
+
+ return 0;
+}
+
+static void
+debug_log_callback(const char* msg, void* userdata)
+{
+ MD_RENDER_HTML* r = (MD_RENDER_HTML*) userdata;
+ if(r->flags & MD_RENDER_FLAG_DEBUG)
+ fprintf(stderr, "MD4C: %s\n", msg);
+}
+
+int
+md_render_html(const MD_CHAR* input, MD_SIZE input_size,
+ void (*process_output)(const MD_CHAR*, MD_SIZE, void*),
+ void* userdata, unsigned parser_flags, unsigned renderer_flags)
+{
+ MD_RENDER_HTML render = { process_output, userdata, renderer_flags, 0 };
+
+ MD_RENDERER renderer = {
+ enter_block_callback,
+ leave_block_callback,
+ enter_span_callback,
+ leave_span_callback,
+ text_callback,
+ debug_log_callback,
+ parser_flags
+ };
+
+ return md_parse(input, input_size, &renderer, (void*) &render);
+}
+
diff --git a/render_html.h b/render_html.h
@@ -0,0 +1,57 @@
+/*
+ * MD4C: Markdown parser for C
+ * (http://github.com/mity/md4c)
+ *
+ * Copyright (c) 2016-2017 Martin Mitas
+ *
+ * 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.
+ */
+
+#ifndef MD4C_RENDER_HTML_H
+#define MD4C_RENDER_HTML_H
+
+#include "shpPackages/md4c/md4c.h"
+
+/* If set, debug output from md_parse() is sent to stderr. */
+#define MD_RENDER_FLAG_DEBUG 0x0001
+#define MD_RENDER_FLAG_VERBATIM_ENTITIES 0x0002
+
+
+/* Render Markdown into HTML.
+ *
+ * Note only contents of <body> tag is generated. Caller must generate
+ * HTML header/footer manually before/after calling md_render_html().
+ *
+ * Params input and input_size specify the Markdown input.
+ * Callback process_output() gets called with chunks of HTML output.
+ * (Typical implementation may just output the bytes to file or append to
+ * some buffer).
+ * Param userdata is just propgated back to process_output() callback.
+ * Param parser_flags are flags from md4c.h propagated to md_parse().
+ * Param render_flags is bitmask of MD_RENDER_FLAG_xxxx.
+ *
+ * Returns -1 on error (if md_parse() fails.)
+ * Returns 0 on success.
+ */
+int md_render_html(const MD_CHAR* input, MD_SIZE input_size,
+ void (*process_output)(const MD_CHAR*, MD_SIZE, void*),
+ void* userdata, unsigned parser_flags, unsigned renderer_flags);
+
+
+#endif /* MD4C_RENDER_HTML_H */
