1 | import "regenerator-runtime/runtime.js";
|
2 |
|
3 | function _defineProperty2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
4 |
|
5 | function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray2(arr, i) || _nonIterableRest(); }
|
6 |
|
7 | function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
8 |
|
9 | function _unsupportedIterableToArray2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray2(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray2(o, minLen); }
|
10 |
|
11 | function _arrayLikeToArray2(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
12 |
|
13 | function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
14 |
|
15 | function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
16 |
|
17 | function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
|
18 |
|
19 | import "core-js/modules/es.regexp.exec.js";
|
20 | import "core-js/modules/es.string.replace.js";
|
21 | import "core-js/modules/es.regexp.constructor.js";
|
22 | import "core-js/modules/es.regexp.to-string.js";
|
23 | import "core-js/modules/es.array.join.js";
|
24 | import "core-js/modules/es.array.map.js";
|
25 | import "core-js/modules/es.array.splice.js";
|
26 | import "core-js/modules/es.array.filter.js";
|
27 | import "core-js/modules/es.object.to-string.js";
|
28 | import "core-js/modules/es.string.from-code-point.js";
|
29 | import "core-js/modules/es.array.slice.js";
|
30 | import "core-js/modules/es.number.constructor.js";
|
31 | import "core-js/modules/es.regexp.flags.js";
|
32 | import "core-js/modules/es.symbol.js";
|
33 | import "core-js/modules/es.symbol.description.js";
|
34 | import "core-js/modules/es.symbol.iterator.js";
|
35 | import "core-js/modules/es.array.iterator.js";
|
36 | import "core-js/modules/es.string.iterator.js";
|
37 | import "core-js/modules/web.dom-collections.iterator.js";
|
38 | import "core-js/modules/es.array.from.js";
|
39 | import "core-js/modules/es.function.name.js";
|
40 | import "core-js/modules/es.object.keys.js";
|
41 | import "core-js/modules/es.object.get-own-property-descriptor.js";
|
42 | import "core-js/modules/web.dom-collections.for-each.js";
|
43 | import "core-js/modules/es.array.concat.js";
|
44 | import "core-js/modules/es.string.split.js";
|
45 | import "core-js/modules/es.array.includes.js";
|
46 | import "core-js/modules/es.string.includes.js";
|
47 | import "core-js/modules/es.object.assign.js";
|
48 | import "core-js/modules/es.string.match.js";
|
49 | import "core-js/modules/es.set.js";
|
50 | import "core-js/modules/es.string.trim.js";
|
51 | import "core-js/modules/esnext.global-this.js";
|
52 | import "core-js/modules/es.object.entries.js";
|
53 | import { _ as _objectWithoutPropertiesLoose, a as _extends, c as commonjsGlobal, b as __awaiter, S as ScrollArea, d as __rest, A as ActionBar, w as window_1 } from './index-681e4b07.js';
|
54 | import React__default, { useState, useCallback } from 'react';
|
55 | import { logger } from '@storybook/client-logger';
|
56 | import { styled } from '@storybook/theming';
|
57 | import memoize from 'memoizerific';
|
58 | import '@storybook/csf';
|
59 | import 'qs';
|
60 | var jsx_1 = jsx;
|
61 | jsx.displayName = 'jsx';
|
62 | jsx.aliases = [];
|
63 |
|
64 | function jsx(Prism) {
|
65 | (function (Prism) {
|
66 | var javascript = Prism.util.clone(Prism.languages.javascript);
|
67 | var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
|
68 | var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
|
69 | var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
|
70 | |
71 |
|
72 |
|
73 |
|
74 |
|
75 | function re(source, flags) {
|
76 | source = source.replace(/<S>/g, function () {
|
77 | return space;
|
78 | }).replace(/<BRACES>/g, function () {
|
79 | return braces;
|
80 | }).replace(/<SPREAD>/g, function () {
|
81 | return spread;
|
82 | });
|
83 | return RegExp(source, flags);
|
84 | }
|
85 |
|
86 | spread = re(spread).source;
|
87 | Prism.languages.jsx = Prism.languages.extend('markup', javascript);
|
88 | Prism.languages.jsx.tag.pattern = re(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source);
|
89 | Prism.languages.jsx.tag.inside['tag'].pattern = /^<\/?[^\s>\/]*/;
|
90 | Prism.languages.jsx.tag.inside['attr-value'].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
|
91 | Prism.languages.jsx.tag.inside['tag'].inside['class-name'] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
|
92 | Prism.languages.jsx.tag.inside['comment'] = javascript['comment'];
|
93 | Prism.languages.insertBefore('inside', 'attr-name', {
|
94 | spread: {
|
95 | pattern: re(/<SPREAD>/.source),
|
96 | inside: Prism.languages.jsx
|
97 | }
|
98 | }, Prism.languages.jsx.tag);
|
99 | Prism.languages.insertBefore('inside', 'special-attr', {
|
100 | script: {
|
101 |
|
102 | pattern: re(/=<BRACES>/.source),
|
103 | alias: 'language-javascript',
|
104 | inside: {
|
105 | 'script-punctuation': {
|
106 | pattern: /^=(?=\{)/,
|
107 | alias: 'punctuation'
|
108 | },
|
109 | rest: Prism.languages.jsx
|
110 | }
|
111 | }
|
112 | }, Prism.languages.jsx.tag);
|
113 |
|
114 | var stringifyToken = function stringifyToken(token) {
|
115 | if (!token) {
|
116 | return '';
|
117 | }
|
118 |
|
119 | if (typeof token === 'string') {
|
120 | return token;
|
121 | }
|
122 |
|
123 | if (typeof token.content === 'string') {
|
124 | return token.content;
|
125 | }
|
126 |
|
127 | return token.content.map(stringifyToken).join('');
|
128 | };
|
129 |
|
130 | var walkTokens = function walkTokens(tokens) {
|
131 | var openedTags = [];
|
132 |
|
133 | for (var i = 0; i < tokens.length; i++) {
|
134 | var token = tokens[i];
|
135 | var notTagNorBrace = false;
|
136 |
|
137 | if (typeof token !== 'string') {
|
138 | if (token.type === 'tag' && token.content[0] && token.content[0].type === 'tag') {
|
139 |
|
140 | if (token.content[0].content[0].content === '</') {
|
141 |
|
142 | if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
|
143 |
|
144 | openedTags.pop();
|
145 | }
|
146 | } else {
|
147 | if (token.content[token.content.length - 1].content === '/>') ;else {
|
148 |
|
149 | openedTags.push({
|
150 | tagName: stringifyToken(token.content[0].content[1]),
|
151 | openedBraces: 0
|
152 | });
|
153 | }
|
154 | }
|
155 | } else if (openedTags.length > 0 && token.type === 'punctuation' && token.content === '{') {
|
156 |
|
157 | openedTags[openedTags.length - 1].openedBraces++;
|
158 | } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === 'punctuation' && token.content === '}') {
|
159 |
|
160 | openedTags[openedTags.length - 1].openedBraces--;
|
161 | } else {
|
162 | notTagNorBrace = true;
|
163 | }
|
164 | }
|
165 |
|
166 | if (notTagNorBrace || typeof token === 'string') {
|
167 | if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
|
168 |
|
169 |
|
170 | var plainText = stringifyToken(token);
|
171 |
|
172 | if (i < tokens.length - 1 && (typeof tokens[i + 1] === 'string' || tokens[i + 1].type === 'plain-text')) {
|
173 | plainText += stringifyToken(tokens[i + 1]);
|
174 | tokens.splice(i + 1, 1);
|
175 | }
|
176 |
|
177 | if (i > 0 && (typeof tokens[i - 1] === 'string' || tokens[i - 1].type === 'plain-text')) {
|
178 | plainText = stringifyToken(tokens[i - 1]) + plainText;
|
179 | tokens.splice(i - 1, 1);
|
180 | i--;
|
181 | }
|
182 |
|
183 | tokens[i] = new Prism.Token('plain-text', plainText, null, plainText);
|
184 | }
|
185 | }
|
186 |
|
187 | if (token.content && typeof token.content !== 'string') {
|
188 | walkTokens(token.content);
|
189 | }
|
190 | }
|
191 | };
|
192 |
|
193 | Prism.hooks.add('after-tokenize', function (env) {
|
194 | if (env.language !== 'jsx' && env.language !== 'tsx') {
|
195 | return;
|
196 | }
|
197 |
|
198 | walkTokens(env.tokens);
|
199 | });
|
200 | })(Prism);
|
201 | }
|
202 |
|
203 | var jsx$1 = jsx_1;
|
204 | var bash_1 = bash;
|
205 | bash.displayName = 'bash';
|
206 | bash.aliases = ['shell'];
|
207 |
|
208 | function bash(Prism) {
|
209 | (function (Prism) {
|
210 |
|
211 |
|
212 |
|
213 |
|
214 | var envVars = '\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b';
|
215 | var commandAfterHeredoc = {
|
216 | pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
|
217 | lookbehind: true,
|
218 | alias: 'punctuation',
|
219 |
|
220 | inside: null
|
221 |
|
222 | };
|
223 | var insideString = {
|
224 | bash: commandAfterHeredoc,
|
225 | environment: {
|
226 | pattern: RegExp('\\$' + envVars),
|
227 | alias: 'constant'
|
228 | },
|
229 | variable: [
|
230 | {
|
231 | pattern: /\$?\(\([\s\S]+?\)\)/,
|
232 | greedy: true,
|
233 | inside: {
|
234 |
|
235 | variable: [{
|
236 | pattern: /(^\$\(\([\s\S]+)\)\)/,
|
237 | lookbehind: true
|
238 | }, /^\$\(\(/],
|
239 | number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
|
240 |
|
241 | operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
|
242 |
|
243 | punctuation: /\(\(?|\)\)?|,|;/
|
244 | }
|
245 | },
|
246 | {
|
247 | pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
|
248 | greedy: true,
|
249 | inside: {
|
250 | variable: /^\$\(|^`|\)$|`$/
|
251 | }
|
252 | },
|
253 | {
|
254 | pattern: /\$\{[^}]+\}/,
|
255 | greedy: true,
|
256 | inside: {
|
257 | operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
|
258 | punctuation: /[\[\]]/,
|
259 | environment: {
|
260 | pattern: RegExp('(\\{)' + envVars),
|
261 | lookbehind: true,
|
262 | alias: 'constant'
|
263 | }
|
264 | }
|
265 | }, /\$(?:\w+|[#?*!@$])/],
|
266 |
|
267 | entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
|
268 | };
|
269 | Prism.languages.bash = {
|
270 | shebang: {
|
271 | pattern: /^#!\s*\/.*/,
|
272 | alias: 'important'
|
273 | },
|
274 | comment: {
|
275 | pattern: /(^|[^"{\\$])#.*/,
|
276 | lookbehind: true
|
277 | },
|
278 | 'function-name': [
|
279 |
|
280 |
|
281 |
|
282 | {
|
283 |
|
284 | pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
|
285 | lookbehind: true,
|
286 | alias: 'function'
|
287 | }, {
|
288 |
|
289 | pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
|
290 | alias: 'function'
|
291 | }],
|
292 |
|
293 | 'for-or-select': {
|
294 | pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
|
295 | alias: 'variable',
|
296 | lookbehind: true
|
297 | },
|
298 |
|
299 |
|
300 | 'assign-left': {
|
301 | pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
|
302 | inside: {
|
303 | environment: {
|
304 | pattern: RegExp('(^|[\\s;|&]|[<>]\\()' + envVars),
|
305 | lookbehind: true,
|
306 | alias: 'constant'
|
307 | }
|
308 | },
|
309 | alias: 'variable',
|
310 | lookbehind: true
|
311 | },
|
312 | string: [
|
313 | {
|
314 | pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
|
315 | lookbehind: true,
|
316 | greedy: true,
|
317 | inside: insideString
|
318 | },
|
319 |
|
320 | {
|
321 | pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
|
322 | lookbehind: true,
|
323 | greedy: true,
|
324 | inside: {
|
325 | bash: commandAfterHeredoc
|
326 | }
|
327 | },
|
328 | {
|
329 |
|
330 | pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
|
331 | lookbehind: true,
|
332 | greedy: true,
|
333 | inside: insideString
|
334 | }, {
|
335 |
|
336 | pattern: /(^|[^$\\])'[^']*'/,
|
337 | lookbehind: true,
|
338 | greedy: true
|
339 | }, {
|
340 |
|
341 | pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
|
342 | greedy: true,
|
343 | inside: {
|
344 | entity: insideString.entity
|
345 | }
|
346 | }],
|
347 | environment: {
|
348 | pattern: RegExp('\\$?' + envVars),
|
349 | alias: 'constant'
|
350 | },
|
351 | variable: insideString.variable,
|
352 | function: {
|
353 | pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
|
354 | lookbehind: true
|
355 | },
|
356 | keyword: {
|
357 | pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
|
358 | lookbehind: true
|
359 | },
|
360 |
|
361 | builtin: {
|
362 | pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
|
363 | lookbehind: true,
|
364 |
|
365 | alias: 'class-name'
|
366 | },
|
367 | boolean: {
|
368 | pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
|
369 | lookbehind: true
|
370 | },
|
371 | 'file-descriptor': {
|
372 | pattern: /\B&\d\b/,
|
373 | alias: 'important'
|
374 | },
|
375 | operator: {
|
376 |
|
377 | pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
|
378 | inside: {
|
379 | 'file-descriptor': {
|
380 | pattern: /^\d/,
|
381 | alias: 'important'
|
382 | }
|
383 | }
|
384 | },
|
385 | punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
|
386 | number: {
|
387 | pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
|
388 | lookbehind: true
|
389 | }
|
390 | };
|
391 | commandAfterHeredoc.inside = Prism.languages.bash;
|
392 |
|
393 |
|
394 | var toBeCopied = ['comment', 'function-name', 'for-or-select', 'assign-left', 'string', 'environment', 'function', 'keyword', 'builtin', 'boolean', 'file-descriptor', 'operator', 'punctuation', 'number'];
|
395 | var inside = insideString.variable[1].inside;
|
396 |
|
397 | for (var i = 0; i < toBeCopied.length; i++) {
|
398 | inside[toBeCopied[i]] = Prism.languages.bash[toBeCopied[i]];
|
399 | }
|
400 |
|
401 | Prism.languages.shell = Prism.languages.bash;
|
402 | })(Prism);
|
403 | }
|
404 |
|
405 | var bash$1 = bash_1;
|
406 | var css_1 = css$1;
|
407 | css$1.displayName = 'css';
|
408 | css$1.aliases = [];
|
409 |
|
410 | function css$1(Prism) {
|
411 | (function (Prism) {
|
412 | var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
|
413 | Prism.languages.css = {
|
414 | comment: /\/\*[\s\S]*?\*\//,
|
415 | atrule: {
|
416 | pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
|
417 | inside: {
|
418 | rule: /^@[\w-]+/,
|
419 | 'selector-function-argument': {
|
420 | pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
|
421 | lookbehind: true,
|
422 | alias: 'selector'
|
423 | },
|
424 | keyword: {
|
425 | pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
|
426 | lookbehind: true
|
427 | }
|
428 |
|
429 | }
|
430 | },
|
431 | url: {
|
432 |
|
433 | pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'),
|
434 | greedy: true,
|
435 | inside: {
|
436 | function: /^url/i,
|
437 | punctuation: /^\(|\)$/,
|
438 | string: {
|
439 | pattern: RegExp('^' + string.source + '$'),
|
440 | alias: 'url'
|
441 | }
|
442 | }
|
443 | },
|
444 | selector: {
|
445 | pattern: RegExp('(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'),
|
446 | lookbehind: true
|
447 | },
|
448 | string: {
|
449 | pattern: string,
|
450 | greedy: true
|
451 | },
|
452 | property: {
|
453 | pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
|
454 | lookbehind: true
|
455 | },
|
456 | important: /!important\b/i,
|
457 | function: {
|
458 | pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
|
459 | lookbehind: true
|
460 | },
|
461 | punctuation: /[(){};:,]/
|
462 | };
|
463 | Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
|
464 | var markup = Prism.languages.markup;
|
465 |
|
466 | if (markup) {
|
467 | markup.tag.addInlined('style', 'css');
|
468 | markup.tag.addAttribute('style', 'css');
|
469 | }
|
470 | })(Prism);
|
471 | }
|
472 |
|
473 | var css$2 = css_1;
|
474 | var jsExtras_1 = jsExtras;
|
475 | jsExtras.displayName = 'jsExtras';
|
476 | jsExtras.aliases = [];
|
477 |
|
478 | function jsExtras(Prism) {
|
479 | (function (Prism) {
|
480 | Prism.languages.insertBefore('javascript', 'function-variable', {
|
481 | 'method-variable': {
|
482 | pattern: RegExp('(\\.\\s*)' + Prism.languages.javascript['function-variable'].pattern.source),
|
483 | lookbehind: true,
|
484 | alias: ['function-variable', 'method', 'function', 'property-access']
|
485 | }
|
486 | });
|
487 | Prism.languages.insertBefore('javascript', 'function', {
|
488 | method: {
|
489 | pattern: RegExp('(\\.\\s*)' + Prism.languages.javascript['function'].source),
|
490 | lookbehind: true,
|
491 | alias: ['function', 'property-access']
|
492 | }
|
493 | });
|
494 | Prism.languages.insertBefore('javascript', 'constant', {
|
495 | 'known-class-name': [{
|
496 |
|
497 |
|
498 | pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
|
499 | alias: 'class-name'
|
500 | }, {
|
501 |
|
502 | pattern: /\b(?:[A-Z]\w*)Error\b/,
|
503 | alias: 'class-name'
|
504 | }]
|
505 | });
|
506 | |
507 |
|
508 |
|
509 |
|
510 |
|
511 |
|
512 |
|
513 |
|
514 | function withId(source, flags) {
|
515 | return RegExp(source.replace(/<ID>/g, function () {
|
516 | return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
|
517 | }), flags);
|
518 | }
|
519 |
|
520 | Prism.languages.insertBefore('javascript', 'keyword', {
|
521 | imports: {
|
522 |
|
523 | pattern: withId(/(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source),
|
524 | lookbehind: true,
|
525 | inside: Prism.languages.javascript
|
526 | },
|
527 | exports: {
|
528 |
|
529 | pattern: withId(/(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source),
|
530 | lookbehind: true,
|
531 | inside: Prism.languages.javascript
|
532 | }
|
533 | });
|
534 | Prism.languages.javascript['keyword'].unshift({
|
535 | pattern: /\b(?:as|default|export|from|import)\b/,
|
536 | alias: 'module'
|
537 | }, {
|
538 | pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
|
539 | alias: 'control-flow'
|
540 | }, {
|
541 | pattern: /\bnull\b/,
|
542 | alias: ['null', 'nil']
|
543 | }, {
|
544 | pattern: /\bundefined\b/,
|
545 | alias: 'nil'
|
546 | });
|
547 | Prism.languages.insertBefore('javascript', 'operator', {
|
548 | spread: {
|
549 | pattern: /\.{3}/,
|
550 | alias: 'operator'
|
551 | },
|
552 | arrow: {
|
553 | pattern: /=>/,
|
554 | alias: 'operator'
|
555 | }
|
556 | });
|
557 | Prism.languages.insertBefore('javascript', 'punctuation', {
|
558 | 'property-access': {
|
559 | pattern: withId(/(\.\s*)#?<ID>/.source),
|
560 | lookbehind: true
|
561 | },
|
562 | 'maybe-class-name': {
|
563 | pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
|
564 | lookbehind: true
|
565 | },
|
566 | dom: {
|
567 |
|
568 | pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
|
569 | alias: 'variable'
|
570 | },
|
571 | console: {
|
572 | pattern: /\bconsole(?=\s*\.)/,
|
573 | alias: 'class-name'
|
574 | }
|
575 | });
|
576 |
|
577 | var maybeClassNameTokens = ['function', 'function-variable', 'method', 'method-variable', 'property-access'];
|
578 |
|
579 | for (var i = 0; i < maybeClassNameTokens.length; i++) {
|
580 | var token = maybeClassNameTokens[i];
|
581 | var value = Prism.languages.javascript[token];
|
582 |
|
583 | if (Prism.util.type(value) === 'RegExp') {
|
584 | value = Prism.languages.javascript[token] = {
|
585 | pattern: value
|
586 | };
|
587 | }
|
588 |
|
589 |
|
590 | var inside = value.inside || {};
|
591 | value.inside = inside;
|
592 | inside['maybe-class-name'] = /^[A-Z][\s\S]*/;
|
593 | }
|
594 | })(Prism);
|
595 | }
|
596 |
|
597 | var jsExtras$1 = jsExtras_1;
|
598 | var json_1 = json;
|
599 | json.displayName = 'json';
|
600 | json.aliases = ['webmanifest'];
|
601 |
|
602 | function json(Prism) {
|
603 |
|
604 | Prism.languages.json = {
|
605 | property: {
|
606 | pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
|
607 | lookbehind: true,
|
608 | greedy: true
|
609 | },
|
610 | string: {
|
611 | pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
|
612 | lookbehind: true,
|
613 | greedy: true
|
614 | },
|
615 | comment: {
|
616 | pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
|
617 | greedy: true
|
618 | },
|
619 | number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
|
620 | punctuation: /[{}[\],]/,
|
621 | operator: /:/,
|
622 | boolean: /\b(?:false|true)\b/,
|
623 | null: {
|
624 | pattern: /\bnull\b/,
|
625 | alias: 'keyword'
|
626 | }
|
627 | };
|
628 | Prism.languages.webmanifest = Prism.languages.json;
|
629 | }
|
630 |
|
631 | var json$1 = json_1;
|
632 | var graphql_1 = graphql;
|
633 | graphql.displayName = 'graphql';
|
634 | graphql.aliases = [];
|
635 |
|
636 | function graphql(Prism) {
|
637 | Prism.languages.graphql = {
|
638 | comment: /#.*/,
|
639 | description: {
|
640 | pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
|
641 | greedy: true,
|
642 | alias: 'string',
|
643 | inside: {
|
644 | 'language-markdown': {
|
645 | pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
|
646 | lookbehind: true,
|
647 | inside: Prism.languages.markdown
|
648 | }
|
649 | }
|
650 | },
|
651 | string: {
|
652 | pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
|
653 | greedy: true
|
654 | },
|
655 | number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
|
656 | boolean: /\b(?:false|true)\b/,
|
657 | variable: /\$[a-z_]\w*/i,
|
658 | directive: {
|
659 | pattern: /@[a-z_]\w*/i,
|
660 | alias: 'function'
|
661 | },
|
662 | 'attr-name': {
|
663 | pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
|
664 | greedy: true
|
665 | },
|
666 | 'atom-input': {
|
667 | pattern: /\b[A-Z]\w*Input\b/,
|
668 | alias: 'class-name'
|
669 | },
|
670 | scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
|
671 | constant: /\b[A-Z][A-Z_\d]*\b/,
|
672 | 'class-name': {
|
673 | pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
|
674 | lookbehind: true
|
675 | },
|
676 | fragment: {
|
677 | pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
|
678 | lookbehind: true,
|
679 | alias: 'function'
|
680 | },
|
681 | 'definition-mutation': {
|
682 | pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
|
683 | lookbehind: true,
|
684 | alias: 'function'
|
685 | },
|
686 | 'definition-query': {
|
687 | pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
|
688 | lookbehind: true,
|
689 | alias: 'function'
|
690 | },
|
691 | keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
|
692 | operator: /[!=|&]|\.{3}/,
|
693 | 'property-query': /\w+(?=\s*\()/,
|
694 | object: /\w+(?=\s*\{)/,
|
695 | punctuation: /[!(){}\[\]:=,]/,
|
696 | property: /\w+/
|
697 | };
|
698 | Prism.hooks.add('after-tokenize', function afterTokenizeGraphql(env) {
|
699 | if (env.language !== 'graphql') {
|
700 | return;
|
701 | }
|
702 | |
703 |
|
704 |
|
705 |
|
706 |
|
707 |
|
708 |
|
709 |
|
710 | var validTokens = env.tokens.filter(function (token) {
|
711 | return typeof token !== 'string' && token.type !== 'comment' && token.type !== 'scalar';
|
712 | });
|
713 | var currentIndex = 0;
|
714 | |
715 |
|
716 |
|
717 |
|
718 |
|
719 |
|
720 |
|
721 | function getToken(offset) {
|
722 | return validTokens[currentIndex + offset];
|
723 | }
|
724 | |
725 |
|
726 |
|
727 |
|
728 |
|
729 |
|
730 |
|
731 |
|
732 |
|
733 | function isTokenType(types, offset) {
|
734 | offset = offset || 0;
|
735 |
|
736 | for (var i = 0; i < types.length; i++) {
|
737 | var token = getToken(i + offset);
|
738 |
|
739 | if (!token || token.type !== types[i]) {
|
740 | return false;
|
741 | }
|
742 | }
|
743 |
|
744 | return true;
|
745 | }
|
746 | |
747 |
|
748 |
|
749 |
|
750 |
|
751 |
|
752 |
|
753 |
|
754 |
|
755 |
|
756 |
|
757 |
|
758 |
|
759 | function findClosingBracket(open, close) {
|
760 | var stackHeight = 1;
|
761 |
|
762 | for (var i = currentIndex; i < validTokens.length; i++) {
|
763 | var token = validTokens[i];
|
764 | var content = token.content;
|
765 |
|
766 | if (token.type === 'punctuation' && typeof content === 'string') {
|
767 | if (open.test(content)) {
|
768 | stackHeight++;
|
769 | } else if (close.test(content)) {
|
770 | stackHeight--;
|
771 |
|
772 | if (stackHeight === 0) {
|
773 | return i;
|
774 | }
|
775 | }
|
776 | }
|
777 | }
|
778 |
|
779 | return -1;
|
780 | }
|
781 | |
782 |
|
783 |
|
784 |
|
785 |
|
786 |
|
787 |
|
788 |
|
789 |
|
790 | function addAlias(token, alias) {
|
791 | var aliases = token.alias;
|
792 |
|
793 | if (!aliases) {
|
794 | token.alias = aliases = [];
|
795 | } else if (!Array.isArray(aliases)) {
|
796 | token.alias = aliases = [aliases];
|
797 | }
|
798 |
|
799 | aliases.push(alias);
|
800 | }
|
801 |
|
802 | for (; currentIndex < validTokens.length;) {
|
803 | var startToken = validTokens[currentIndex++];
|
804 |
|
805 | if (startToken.type === 'keyword' && startToken.content === 'mutation') {
|
806 |
|
807 | var inputVariables = [];
|
808 |
|
809 | if (isTokenType(['definition-mutation', 'punctuation']) && getToken(1).content === '(') {
|
810 |
|
811 | currentIndex += 2;
|
812 |
|
813 | var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
|
814 |
|
815 | if (definitionEnd === -1) {
|
816 | continue;
|
817 | }
|
818 |
|
819 |
|
820 | for (; currentIndex < definitionEnd; currentIndex++) {
|
821 | var t = getToken(0);
|
822 |
|
823 | if (t.type === 'variable') {
|
824 | addAlias(t, 'variable-input');
|
825 | inputVariables.push(t.content);
|
826 | }
|
827 | }
|
828 |
|
829 | currentIndex = definitionEnd + 1;
|
830 | }
|
831 |
|
832 | if (isTokenType(['punctuation', 'property-query']) && getToken(0).content === '{') {
|
833 | currentIndex++;
|
834 |
|
835 | addAlias(getToken(0), 'property-mutation');
|
836 |
|
837 | if (inputVariables.length > 0) {
|
838 | var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
|
839 |
|
840 | if (mutationEnd === -1) {
|
841 | continue;
|
842 | }
|
843 |
|
844 |
|
845 | for (var i = currentIndex; i < mutationEnd; i++) {
|
846 | var varToken = validTokens[i];
|
847 |
|
848 | if (varToken.type === 'variable' && inputVariables.indexOf(varToken.content) >= 0) {
|
849 | addAlias(varToken, 'variable-input');
|
850 | }
|
851 | }
|
852 | }
|
853 | }
|
854 | }
|
855 | }
|
856 | });
|
857 | }
|
858 |
|
859 | var graphql$1 = graphql_1;
|
860 | var markup_1 = markup$1;
|
861 | markup$1.displayName = 'markup';
|
862 | markup$1.aliases = ['html', 'mathml', 'svg', 'xml', 'ssml', 'atom', 'rss'];
|
863 |
|
864 | function markup$1(Prism) {
|
865 | Prism.languages.markup = {
|
866 | comment: {
|
867 | pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
|
868 | greedy: true
|
869 | },
|
870 | prolog: {
|
871 | pattern: /<\?[\s\S]+?\?>/,
|
872 | greedy: true
|
873 | },
|
874 | doctype: {
|
875 |
|
876 | pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
|
877 | greedy: true,
|
878 | inside: {
|
879 | 'internal-subset': {
|
880 | pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
|
881 | lookbehind: true,
|
882 | greedy: true,
|
883 | inside: null
|
884 |
|
885 | },
|
886 | string: {
|
887 | pattern: /"[^"]*"|'[^']*'/,
|
888 | greedy: true
|
889 | },
|
890 | punctuation: /^<!|>$|[[\]]/,
|
891 | 'doctype-tag': /^DOCTYPE/i,
|
892 | name: /[^\s<>'"]+/
|
893 | }
|
894 | },
|
895 | cdata: {
|
896 | pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
897 | greedy: true
|
898 | },
|
899 | tag: {
|
900 | pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
|
901 | greedy: true,
|
902 | inside: {
|
903 | tag: {
|
904 | pattern: /^<\/?[^\s>\/]+/,
|
905 | inside: {
|
906 | punctuation: /^<\/?/,
|
907 | namespace: /^[^\s>\/:]+:/
|
908 | }
|
909 | },
|
910 | 'special-attr': [],
|
911 | 'attr-value': {
|
912 | pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
|
913 | inside: {
|
914 | punctuation: [{
|
915 | pattern: /^=/,
|
916 | alias: 'attr-equals'
|
917 | }, /"|'/]
|
918 | }
|
919 | },
|
920 | punctuation: /\/?>/,
|
921 | 'attr-name': {
|
922 | pattern: /[^\s>\/]+/,
|
923 | inside: {
|
924 | namespace: /^[^\s>\/:]+:/
|
925 | }
|
926 | }
|
927 | }
|
928 | },
|
929 | entity: [{
|
930 | pattern: /&[\da-z]{1,8};/i,
|
931 | alias: 'named-entity'
|
932 | }, /&#x?[\da-f]{1,8};/i]
|
933 | };
|
934 | Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity'];
|
935 | Prism.languages.markup['doctype'].inside['internal-subset'].inside = Prism.languages.markup;
|
936 |
|
937 | Prism.hooks.add('wrap', function (env) {
|
938 | if (env.type === 'entity') {
|
939 | env.attributes['title'] = env.content.value.replace(/&/, '&');
|
940 | }
|
941 | });
|
942 | Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {
|
943 | |
944 |
|
945 |
|
946 |
|
947 |
|
948 |
|
949 |
|
950 |
|
951 |
|
952 |
|
953 |
|
954 | value: function addInlined(tagName, lang) {
|
955 | var includedCdataInside = {};
|
956 | includedCdataInside['language-' + lang] = {
|
957 | pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
|
958 | lookbehind: true,
|
959 | inside: Prism.languages[lang]
|
960 | };
|
961 | includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
|
962 | var inside = {
|
963 | 'included-cdata': {
|
964 | pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
965 | inside: includedCdataInside
|
966 | }
|
967 | };
|
968 | inside['language-' + lang] = {
|
969 | pattern: /[\s\S]+/,
|
970 | inside: Prism.languages[lang]
|
971 | };
|
972 | var def = {};
|
973 | def[tagName] = {
|
974 | pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () {
|
975 | return tagName;
|
976 | }), 'i'),
|
977 | lookbehind: true,
|
978 | greedy: true,
|
979 | inside: inside
|
980 | };
|
981 | Prism.languages.insertBefore('markup', 'cdata', def);
|
982 | }
|
983 | });
|
984 | Object.defineProperty(Prism.languages.markup.tag, 'addAttribute', {
|
985 | |
986 |
|
987 |
|
988 |
|
989 |
|
990 |
|
991 |
|
992 |
|
993 |
|
994 |
|
995 |
|
996 | value: function value(attrName, lang) {
|
997 | Prism.languages.markup.tag.inside['special-attr'].push({
|
998 | pattern: RegExp(/(^|["'\s])/.source + '(?:' + attrName + ')' + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, 'i'),
|
999 | lookbehind: true,
|
1000 | inside: {
|
1001 | 'attr-name': /^[^\s=]+/,
|
1002 | 'attr-value': {
|
1003 | pattern: /=[\s\S]+/,
|
1004 | inside: {
|
1005 | value: {
|
1006 | pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
|
1007 | lookbehind: true,
|
1008 | alias: [lang, 'language-' + lang],
|
1009 | inside: Prism.languages[lang]
|
1010 | },
|
1011 | punctuation: [{
|
1012 | pattern: /^=/,
|
1013 | alias: 'attr-equals'
|
1014 | }, /"|'/]
|
1015 | }
|
1016 | }
|
1017 | }
|
1018 | });
|
1019 | }
|
1020 | });
|
1021 | Prism.languages.html = Prism.languages.markup;
|
1022 | Prism.languages.mathml = Prism.languages.markup;
|
1023 | Prism.languages.svg = Prism.languages.markup;
|
1024 | Prism.languages.xml = Prism.languages.extend('markup', {});
|
1025 | Prism.languages.ssml = Prism.languages.xml;
|
1026 | Prism.languages.atom = Prism.languages.xml;
|
1027 | Prism.languages.rss = Prism.languages.xml;
|
1028 | }
|
1029 |
|
1030 | var markup$2 = markup_1;
|
1031 | var markdown_1 = markdown;
|
1032 | markdown.displayName = 'markdown';
|
1033 | markdown.aliases = ['md'];
|
1034 |
|
1035 | function markdown(Prism) {
|
1036 | (function (Prism) {
|
1037 |
|
1038 | var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
|
1039 | |
1040 |
|
1041 |
|
1042 |
|
1043 |
|
1044 |
|
1045 |
|
1046 |
|
1047 |
|
1048 |
|
1049 |
|
1050 | function createInline(pattern) {
|
1051 | pattern = pattern.replace(/<inner>/g, function () {
|
1052 | return inner;
|
1053 | });
|
1054 | return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + '(?:' + pattern + ')');
|
1055 | }
|
1056 |
|
1057 | var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source;
|
1058 | var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function () {
|
1059 | return tableCell;
|
1060 | });
|
1061 | var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
|
1062 | Prism.languages.markdown = Prism.languages.extend('markup', {});
|
1063 | Prism.languages.insertBefore('markdown', 'prolog', {
|
1064 | 'front-matter-block': {
|
1065 | pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
|
1066 | lookbehind: true,
|
1067 | greedy: true,
|
1068 | inside: {
|
1069 | punctuation: /^---|---$/,
|
1070 | 'front-matter': {
|
1071 | pattern: /\S+(?:\s+\S+)*/,
|
1072 | alias: ['yaml', 'language-yaml'],
|
1073 | inside: Prism.languages.yaml
|
1074 | }
|
1075 | }
|
1076 | },
|
1077 | blockquote: {
|
1078 |
|
1079 | pattern: /^>(?:[\t ]*>)*/m,
|
1080 | alias: 'punctuation'
|
1081 | },
|
1082 | table: {
|
1083 | pattern: RegExp('^' + tableRow + tableLine + '(?:' + tableRow + ')*', 'm'),
|
1084 | inside: {
|
1085 | 'table-data-rows': {
|
1086 | pattern: RegExp('^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$'),
|
1087 | lookbehind: true,
|
1088 | inside: {
|
1089 | 'table-data': {
|
1090 | pattern: RegExp(tableCell),
|
1091 | inside: Prism.languages.markdown
|
1092 | },
|
1093 | punctuation: /\|/
|
1094 | }
|
1095 | },
|
1096 | 'table-line': {
|
1097 | pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'),
|
1098 | lookbehind: true,
|
1099 | inside: {
|
1100 | punctuation: /\||:?-{3,}:?/
|
1101 | }
|
1102 | },
|
1103 | 'table-header-row': {
|
1104 | pattern: RegExp('^' + tableRow + '$'),
|
1105 | inside: {
|
1106 | 'table-header': {
|
1107 | pattern: RegExp(tableCell),
|
1108 | alias: 'important',
|
1109 | inside: Prism.languages.markdown
|
1110 | },
|
1111 | punctuation: /\|/
|
1112 | }
|
1113 | }
|
1114 | }
|
1115 | },
|
1116 | code: [{
|
1117 |
|
1118 | pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
|
1119 | lookbehind: true,
|
1120 | alias: 'keyword'
|
1121 | }, {
|
1122 |
|
1123 |
|
1124 |
|
1125 | pattern: /^```[\s\S]*?^```$/m,
|
1126 | greedy: true,
|
1127 | inside: {
|
1128 | 'code-block': {
|
1129 | pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
|
1130 | lookbehind: true
|
1131 | },
|
1132 | 'code-language': {
|
1133 | pattern: /^(```).+/,
|
1134 | lookbehind: true
|
1135 | },
|
1136 | punctuation: /```/
|
1137 | }
|
1138 | }],
|
1139 | title: [{
|
1140 |
|
1141 |
|
1142 |
|
1143 |
|
1144 | pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
|
1145 | alias: 'important',
|
1146 | inside: {
|
1147 | punctuation: /==+$|--+$/
|
1148 | }
|
1149 | }, {
|
1150 |
|
1151 |
|
1152 | pattern: /(^\s*)#.+/m,
|
1153 | lookbehind: true,
|
1154 | alias: 'important',
|
1155 | inside: {
|
1156 | punctuation: /^#+|#+$/
|
1157 | }
|
1158 | }],
|
1159 | hr: {
|
1160 |
|
1161 |
|
1162 |
|
1163 |
|
1164 | pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
|
1165 | lookbehind: true,
|
1166 | alias: 'punctuation'
|
1167 | },
|
1168 | list: {
|
1169 |
|
1170 |
|
1171 |
|
1172 |
|
1173 | pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
|
1174 | lookbehind: true,
|
1175 | alias: 'punctuation'
|
1176 | },
|
1177 | 'url-reference': {
|
1178 |
|
1179 |
|
1180 |
|
1181 |
|
1182 | pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
|
1183 | inside: {
|
1184 | variable: {
|
1185 | pattern: /^(!?\[)[^\]]+/,
|
1186 | lookbehind: true
|
1187 | },
|
1188 | string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
|
1189 | punctuation: /^[\[\]!:]|[<>]/
|
1190 | },
|
1191 | alias: 'url'
|
1192 | },
|
1193 | bold: {
|
1194 |
|
1195 |
|
1196 |
|
1197 | pattern: createInline(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
|
1198 | lookbehind: true,
|
1199 | greedy: true,
|
1200 | inside: {
|
1201 | content: {
|
1202 | pattern: /(^..)[\s\S]+(?=..$)/,
|
1203 | lookbehind: true,
|
1204 | inside: {}
|
1205 |
|
1206 | },
|
1207 | punctuation: /\*\*|__/
|
1208 | }
|
1209 | },
|
1210 | italic: {
|
1211 |
|
1212 |
|
1213 |
|
1214 | pattern: createInline(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
|
1215 | lookbehind: true,
|
1216 | greedy: true,
|
1217 | inside: {
|
1218 | content: {
|
1219 | pattern: /(^.)[\s\S]+(?=.$)/,
|
1220 | lookbehind: true,
|
1221 | inside: {}
|
1222 |
|
1223 | },
|
1224 | punctuation: /[*_]/
|
1225 | }
|
1226 | },
|
1227 | strike: {
|
1228 |
|
1229 |
|
1230 |
|
1231 | pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
|
1232 | lookbehind: true,
|
1233 | greedy: true,
|
1234 | inside: {
|
1235 | content: {
|
1236 | pattern: /(^~~?)[\s\S]+(?=\1$)/,
|
1237 | lookbehind: true,
|
1238 | inside: {}
|
1239 |
|
1240 | },
|
1241 | punctuation: /~~?/
|
1242 | }
|
1243 | },
|
1244 | 'code-snippet': {
|
1245 |
|
1246 |
|
1247 | pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
|
1248 | lookbehind: true,
|
1249 | greedy: true,
|
1250 | alias: ['code', 'keyword']
|
1251 | },
|
1252 | url: {
|
1253 |
|
1254 |
|
1255 |
|
1256 | pattern: createInline(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
|
1257 | lookbehind: true,
|
1258 | greedy: true,
|
1259 | inside: {
|
1260 | operator: /^!/,
|
1261 | content: {
|
1262 | pattern: /(^\[)[^\]]+(?=\])/,
|
1263 | lookbehind: true,
|
1264 | inside: {}
|
1265 |
|
1266 | },
|
1267 | variable: {
|
1268 | pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
|
1269 | lookbehind: true
|
1270 | },
|
1271 | url: {
|
1272 | pattern: /(^\]\()[^\s)]+/,
|
1273 | lookbehind: true
|
1274 | },
|
1275 | string: {
|
1276 | pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
|
1277 | lookbehind: true
|
1278 | }
|
1279 | }
|
1280 | }
|
1281 | });
|
1282 | ['url', 'bold', 'italic', 'strike'].forEach(function (token) {
|
1283 | ['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach(function (inside) {
|
1284 | if (token !== inside) {
|
1285 | Prism.languages.markdown[token].inside.content.inside[inside] = Prism.languages.markdown[inside];
|
1286 | }
|
1287 | });
|
1288 | });
|
1289 | Prism.hooks.add('after-tokenize', function (env) {
|
1290 | if (env.language !== 'markdown' && env.language !== 'md') {
|
1291 | return;
|
1292 | }
|
1293 |
|
1294 | function walkTokens(tokens) {
|
1295 | if (!tokens || typeof tokens === 'string') {
|
1296 | return;
|
1297 | }
|
1298 |
|
1299 | for (var i = 0, l = tokens.length; i < l; i++) {
|
1300 | var token = tokens[i];
|
1301 |
|
1302 | if (token.type !== 'code') {
|
1303 | walkTokens(token.content);
|
1304 | continue;
|
1305 | }
|
1306 | |
1307 |
|
1308 |
|
1309 |
|
1310 |
|
1311 |
|
1312 |
|
1313 |
|
1314 |
|
1315 |
|
1316 |
|
1317 |
|
1318 |
|
1319 |
|
1320 |
|
1321 | var codeLang = token.content[1];
|
1322 | var codeBlock = token.content[3];
|
1323 |
|
1324 | if (codeLang && codeBlock && codeLang.type === 'code-language' && codeBlock.type === 'code-block' && typeof codeLang.content === 'string') {
|
1325 |
|
1326 |
|
1327 | var lang = codeLang.content.replace(/\b#/g, 'sharp').replace(/\b\+\+/g, 'pp');
|
1328 |
|
1329 | lang = (/[a-z][\w-]*/i.exec(lang) || [''])[0].toLowerCase();
|
1330 | var alias = 'language-' + lang;
|
1331 |
|
1332 | if (!codeBlock.alias) {
|
1333 | codeBlock.alias = [alias];
|
1334 | } else if (typeof codeBlock.alias === 'string') {
|
1335 | codeBlock.alias = [codeBlock.alias, alias];
|
1336 | } else {
|
1337 | codeBlock.alias.push(alias);
|
1338 | }
|
1339 | }
|
1340 | }
|
1341 | }
|
1342 |
|
1343 | walkTokens(env.tokens);
|
1344 | });
|
1345 | Prism.hooks.add('wrap', function (env) {
|
1346 | if (env.type !== 'code-block') {
|
1347 | return;
|
1348 | }
|
1349 |
|
1350 | var codeLang = '';
|
1351 |
|
1352 | for (var i = 0, l = env.classes.length; i < l; i++) {
|
1353 | var cls = env.classes[i];
|
1354 | var match = /language-(.+)/.exec(cls);
|
1355 |
|
1356 | if (match) {
|
1357 | codeLang = match[1];
|
1358 | break;
|
1359 | }
|
1360 | }
|
1361 |
|
1362 | var grammar = Prism.languages[codeLang];
|
1363 |
|
1364 | if (!grammar) {
|
1365 | if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) {
|
1366 | var id = 'md-' + new Date().valueOf() + '-' + Math.floor(Math.random() * 1e16);
|
1367 | env.attributes['id'] = id;
|
1368 | Prism.plugins.autoloader.loadLanguages(codeLang, function () {
|
1369 | var ele = document.getElementById(id);
|
1370 |
|
1371 | if (ele) {
|
1372 | ele.innerHTML = Prism.highlight(ele.textContent, Prism.languages[codeLang], codeLang);
|
1373 | }
|
1374 | });
|
1375 | }
|
1376 | } else {
|
1377 | env.content = Prism.highlight(textContent(env.content.value), grammar, codeLang);
|
1378 | }
|
1379 | });
|
1380 | var tagPattern = RegExp(Prism.languages.markup.tag.pattern.source, 'gi');
|
1381 | |
1382 |
|
1383 |
|
1384 |
|
1385 |
|
1386 |
|
1387 |
|
1388 |
|
1389 | var KNOWN_ENTITY_NAMES = {
|
1390 | amp: '&',
|
1391 | lt: '<',
|
1392 | gt: '>',
|
1393 | quot: '"'
|
1394 | };
|
1395 |
|
1396 | var fromCodePoint = String.fromCodePoint || String.fromCharCode;
|
1397 | |
1398 |
|
1399 |
|
1400 |
|
1401 |
|
1402 |
|
1403 |
|
1404 | function textContent(html) {
|
1405 |
|
1406 | var text = html.replace(tagPattern, '');
|
1407 |
|
1408 | text = text.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function (m, code) {
|
1409 | code = code.toLowerCase();
|
1410 |
|
1411 | if (code[0] === '#') {
|
1412 | var value;
|
1413 |
|
1414 | if (code[1] === 'x') {
|
1415 | value = parseInt(code.slice(2), 16);
|
1416 | } else {
|
1417 | value = Number(code.slice(1));
|
1418 | }
|
1419 |
|
1420 | return fromCodePoint(value);
|
1421 | } else {
|
1422 | var known = KNOWN_ENTITY_NAMES[code];
|
1423 |
|
1424 | if (known) {
|
1425 | return known;
|
1426 | }
|
1427 |
|
1428 |
|
1429 | return m;
|
1430 | }
|
1431 | });
|
1432 | return text;
|
1433 | }
|
1434 |
|
1435 | Prism.languages.md = Prism.languages.markdown;
|
1436 | })(Prism);
|
1437 | }
|
1438 |
|
1439 | var markdown$1 = markdown_1;
|
1440 | var yaml_1 = yaml;
|
1441 | yaml.displayName = 'yaml';
|
1442 | yaml.aliases = ['yml'];
|
1443 |
|
1444 | function yaml(Prism) {
|
1445 | (function (Prism) {
|
1446 |
|
1447 |
|
1448 | var anchorOrAlias = /[*&][^\s[\]{},]+/;
|
1449 |
|
1450 | var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
|
1451 |
|
1452 | var properties = '(?:' + tag.source + '(?:[ \t]+' + anchorOrAlias.source + ')?|' + anchorOrAlias.source + '(?:[ \t]+' + tag.source + ')?)';
|
1453 |
|
1454 |
|
1455 |
|
1456 | var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function () {
|
1457 | return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
|
1458 | });
|
1459 | var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
|
1460 | |
1461 |
|
1462 |
|
1463 |
|
1464 |
|
1465 |
|
1466 |
|
1467 | function createValuePattern(value, flags) {
|
1468 | flags = (flags || '').replace(/m/g, '') + 'm';
|
1469 |
|
1470 | var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function () {
|
1471 | return properties;
|
1472 | }).replace(/<<value>>/g, function () {
|
1473 | return value;
|
1474 | });
|
1475 | return RegExp(pattern, flags);
|
1476 | }
|
1477 |
|
1478 | Prism.languages.yaml = {
|
1479 | scalar: {
|
1480 | pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function () {
|
1481 | return properties;
|
1482 | })),
|
1483 | lookbehind: true,
|
1484 | alias: 'string'
|
1485 | },
|
1486 | comment: /#.*/,
|
1487 | key: {
|
1488 | pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function () {
|
1489 | return properties;
|
1490 | }).replace(/<<key>>/g, function () {
|
1491 | return '(?:' + plainKey + '|' + string + ')';
|
1492 | })),
|
1493 | lookbehind: true,
|
1494 | greedy: true,
|
1495 | alias: 'atrule'
|
1496 | },
|
1497 | directive: {
|
1498 | pattern: /(^[ \t]*)%.+/m,
|
1499 | lookbehind: true,
|
1500 | alias: 'important'
|
1501 | },
|
1502 | datetime: {
|
1503 | pattern: createValuePattern(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
|
1504 | lookbehind: true,
|
1505 | alias: 'number'
|
1506 | },
|
1507 | boolean: {
|
1508 | pattern: createValuePattern(/false|true/.source, 'i'),
|
1509 | lookbehind: true,
|
1510 | alias: 'important'
|
1511 | },
|
1512 | null: {
|
1513 | pattern: createValuePattern(/null|~/.source, 'i'),
|
1514 | lookbehind: true,
|
1515 | alias: 'important'
|
1516 | },
|
1517 | string: {
|
1518 | pattern: createValuePattern(string),
|
1519 | lookbehind: true,
|
1520 | greedy: true
|
1521 | },
|
1522 | number: {
|
1523 | pattern: createValuePattern(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, 'i'),
|
1524 | lookbehind: true
|
1525 | },
|
1526 | tag: tag,
|
1527 | important: anchorOrAlias,
|
1528 | punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
|
1529 | };
|
1530 | Prism.languages.yml = Prism.languages.yaml;
|
1531 | })(Prism);
|
1532 | }
|
1533 |
|
1534 | var yaml$1 = yaml_1;
|
1535 | var typescript_1 = typescript;
|
1536 | typescript.displayName = 'typescript';
|
1537 | typescript.aliases = ['ts'];
|
1538 |
|
1539 | function typescript(Prism) {
|
1540 | (function (Prism) {
|
1541 | Prism.languages.typescript = Prism.languages.extend('javascript', {
|
1542 | 'class-name': {
|
1543 | pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
|
1544 | lookbehind: true,
|
1545 | greedy: true,
|
1546 | inside: null
|
1547 |
|
1548 | },
|
1549 | builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
|
1550 | });
|
1551 |
|
1552 | Prism.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/,
|
1553 | /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
|
1554 | /\btype\b(?=\s*(?:[\{*]|$))/);
|
1555 |
|
1556 | delete Prism.languages.typescript['parameter'];
|
1557 | delete Prism.languages.typescript['literal-property'];
|
1558 |
|
1559 | var typeInside = Prism.languages.extend('typescript', {});
|
1560 | delete typeInside['class-name'];
|
1561 | Prism.languages.typescript['class-name'].inside = typeInside;
|
1562 | Prism.languages.insertBefore('typescript', 'function', {
|
1563 | decorator: {
|
1564 | pattern: /@[$\w\xA0-\uFFFF]+/,
|
1565 | inside: {
|
1566 | at: {
|
1567 | pattern: /^@/,
|
1568 | alias: 'operator'
|
1569 | },
|
1570 | function: /^[\s\S]+/
|
1571 | }
|
1572 | },
|
1573 | 'generic-function': {
|
1574 |
|
1575 | pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
|
1576 | greedy: true,
|
1577 | inside: {
|
1578 | function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
|
1579 | generic: {
|
1580 | pattern: /<[\s\S]+/,
|
1581 |
|
1582 | alias: 'class-name',
|
1583 | inside: typeInside
|
1584 | }
|
1585 | }
|
1586 | }
|
1587 | });
|
1588 | Prism.languages.ts = Prism.languages.typescript;
|
1589 | })(Prism);
|
1590 | }
|
1591 |
|
1592 | var typescript$1 = typescript_1;
|
1593 | var refractorJsx = jsx_1;
|
1594 | var refractorTypescript = typescript_1;
|
1595 | var tsx_1 = tsx;
|
1596 | tsx.displayName = 'tsx';
|
1597 | tsx.aliases = [];
|
1598 |
|
1599 | function tsx(Prism) {
|
1600 | Prism.register(refractorJsx);
|
1601 | Prism.register(refractorTypescript);
|
1602 |
|
1603 | (function (Prism) {
|
1604 | var typescript = Prism.util.clone(Prism.languages.typescript);
|
1605 | Prism.languages.tsx = Prism.languages.extend('jsx', typescript);
|
1606 |
|
1607 | delete Prism.languages.tsx['parameter'];
|
1608 | delete Prism.languages.tsx['literal-property'];
|
1609 |
|
1610 |
|
1611 |
|
1612 | var tag = Prism.languages.tsx.tag;
|
1613 | tag.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + '(?:' + tag.pattern.source + ')', tag.pattern.flags);
|
1614 | tag.lookbehind = true;
|
1615 | })(Prism);
|
1616 | }
|
1617 |
|
1618 | var tsx$1 = tsx_1;
|
1619 |
|
1620 | function _objectWithoutProperties(source, excluded) {
|
1621 | if (source == null) return {};
|
1622 |
|
1623 | var target = _objectWithoutPropertiesLoose(source, excluded);
|
1624 |
|
1625 | var key, i;
|
1626 |
|
1627 | if (Object.getOwnPropertySymbols) {
|
1628 | var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
|
1629 |
|
1630 | for (i = 0; i < sourceSymbolKeys.length; i++) {
|
1631 | key = sourceSymbolKeys[i];
|
1632 | if (excluded.indexOf(key) >= 0) continue;
|
1633 | if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
|
1634 | target[key] = source[key];
|
1635 | }
|
1636 | }
|
1637 |
|
1638 | return target;
|
1639 | }
|
1640 |
|
1641 | function _arrayLikeToArray(arr, len) {
|
1642 | if (len == null || len > arr.length) len = arr.length;
|
1643 |
|
1644 | for (var i = 0, arr2 = new Array(len); i < len; i++) {
|
1645 | arr2[i] = arr[i];
|
1646 | }
|
1647 |
|
1648 | return arr2;
|
1649 | }
|
1650 |
|
1651 | function _arrayWithoutHoles(arr) {
|
1652 | if (Array.isArray(arr)) return _arrayLikeToArray(arr);
|
1653 | }
|
1654 |
|
1655 | function _iterableToArray(iter) {
|
1656 | if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
|
1657 | }
|
1658 |
|
1659 | function _unsupportedIterableToArray(o, minLen) {
|
1660 | if (!o) return;
|
1661 | if (typeof o === "string") return _arrayLikeToArray(o, minLen);
|
1662 | var n = Object.prototype.toString.call(o).slice(8, -1);
|
1663 | if (n === "Object" && o.constructor) n = o.constructor.name;
|
1664 | if (n === "Map" || n === "Set") return Array.from(o);
|
1665 | if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
|
1666 | }
|
1667 |
|
1668 | function _nonIterableSpread() {
|
1669 | throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
1670 | }
|
1671 |
|
1672 | function _toConsumableArray(arr) {
|
1673 | return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
|
1674 | }
|
1675 |
|
1676 | function _defineProperty(obj, key, value) {
|
1677 | if (key in obj) {
|
1678 | Object.defineProperty(obj, key, {
|
1679 | value: value,
|
1680 | enumerable: true,
|
1681 | configurable: true,
|
1682 | writable: true
|
1683 | });
|
1684 | } else {
|
1685 | obj[key] = value;
|
1686 | }
|
1687 |
|
1688 | return obj;
|
1689 | }
|
1690 |
|
1691 | function _objectSpread(target) {
|
1692 | for (var i = 1; i < arguments.length; i++) {
|
1693 | var source = arguments[i] != null ? Object(arguments[i]) : {};
|
1694 | var ownKeys = Object.keys(source);
|
1695 |
|
1696 | if (typeof Object.getOwnPropertySymbols === 'function') {
|
1697 | ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) {
|
1698 | return Object.getOwnPropertyDescriptor(source, sym).enumerable;
|
1699 | }));
|
1700 | }
|
1701 |
|
1702 | ownKeys.forEach(function (key) {
|
1703 | _defineProperty(target, key, source[key]);
|
1704 | });
|
1705 | }
|
1706 |
|
1707 | return target;
|
1708 | }
|
1709 |
|
1710 |
|
1711 |
|
1712 |
|
1713 | function powerSetPermutations(arr) {
|
1714 | var arrLength = arr.length;
|
1715 | if (arrLength === 0 || arrLength === 1) return arr;
|
1716 |
|
1717 | if (arrLength === 2) {
|
1718 |
|
1719 | return [arr[0], arr[1], "".concat(arr[0], ".").concat(arr[1]), "".concat(arr[1], ".").concat(arr[0])];
|
1720 | }
|
1721 |
|
1722 | if (arrLength === 3) {
|
1723 | return [arr[0], arr[1], arr[2], "".concat(arr[0], ".").concat(arr[1]), "".concat(arr[0], ".").concat(arr[2]), "".concat(arr[1], ".").concat(arr[0]), "".concat(arr[1], ".").concat(arr[2]), "".concat(arr[2], ".").concat(arr[0]), "".concat(arr[2], ".").concat(arr[1]), "".concat(arr[0], ".").concat(arr[1], ".").concat(arr[2]), "".concat(arr[0], ".").concat(arr[2], ".").concat(arr[1]), "".concat(arr[1], ".").concat(arr[0], ".").concat(arr[2]), "".concat(arr[1], ".").concat(arr[2], ".").concat(arr[0]), "".concat(arr[2], ".").concat(arr[0], ".").concat(arr[1]), "".concat(arr[2], ".").concat(arr[1], ".").concat(arr[0])];
|
1724 | }
|
1725 |
|
1726 | if (arrLength >= 4) {
|
1727 |
|
1728 |
|
1729 | return [arr[0], arr[1], arr[2], arr[3], "".concat(arr[0], ".").concat(arr[1]), "".concat(arr[0], ".").concat(arr[2]), "".concat(arr[0], ".").concat(arr[3]), "".concat(arr[1], ".").concat(arr[0]), "".concat(arr[1], ".").concat(arr[2]), "".concat(arr[1], ".").concat(arr[3]), "".concat(arr[2], ".").concat(arr[0]), "".concat(arr[2], ".").concat(arr[1]), "".concat(arr[2], ".").concat(arr[3]), "".concat(arr[3], ".").concat(arr[0]), "".concat(arr[3], ".").concat(arr[1]), "".concat(arr[3], ".").concat(arr[2]), "".concat(arr[0], ".").concat(arr[1], ".").concat(arr[2]), "".concat(arr[0], ".").concat(arr[1], ".").concat(arr[3]), "".concat(arr[0], ".").concat(arr[2], ".").concat(arr[1]), "".concat(arr[0], ".").concat(arr[2], ".").concat(arr[3]), "".concat(arr[0], ".").concat(arr[3], ".").concat(arr[1]), "".concat(arr[0], ".").concat(arr[3], ".").concat(arr[2]), "".concat(arr[1], ".").concat(arr[0], ".").concat(arr[2]), "".concat(arr[1], ".").concat(arr[0], ".").concat(arr[3]), "".concat(arr[1], ".").concat(arr[2], ".").concat(arr[0]), "".concat(arr[1], ".").concat(arr[2], ".").concat(arr[3]), "".concat(arr[1], ".").concat(arr[3], ".").concat(arr[0]), "".concat(arr[1], ".").concat(arr[3], ".").concat(arr[2]), "".concat(arr[2], ".").concat(arr[0], ".").concat(arr[1]), "".concat(arr[2], ".").concat(arr[0], ".").concat(arr[3]), "".concat(arr[2], ".").concat(arr[1], ".").concat(arr[0]), "".concat(arr[2], ".").concat(arr[1], ".").concat(arr[3]), "".concat(arr[2], ".").concat(arr[3], ".").concat(arr[0]), "".concat(arr[2], ".").concat(arr[3], ".").concat(arr[1]), "".concat(arr[3], ".").concat(arr[0], ".").concat(arr[1]), "".concat(arr[3], ".").concat(arr[0], ".").concat(arr[2]), "".concat(arr[3], ".").concat(arr[1], ".").concat(arr[0]), "".concat(arr[3], ".").concat(arr[1], ".").concat(arr[2]), "".concat(arr[3], ".").concat(arr[2], ".").concat(arr[0]), "".concat(arr[3], ".").concat(arr[2], ".").concat(arr[1]), "".concat(arr[0], ".").concat(arr[1], ".").concat(arr[2], ".").concat(arr[3]), "".concat(arr[0], ".").concat(arr[1], ".").concat(arr[3], ".").concat(arr[2]), "".concat(arr[0], ".").concat(arr[2], ".").concat(arr[1], ".").concat(arr[3]), "".concat(arr[0], ".").concat(arr[2], ".").concat(arr[3], ".").concat(arr[1]), "".concat(arr[0], ".").concat(arr[3], ".").concat(arr[1], ".").concat(arr[2]), "".concat(arr[0], ".").concat(arr[3], ".").concat(arr[2], ".").concat(arr[1]), "".concat(arr[1], ".").concat(arr[0], ".").concat(arr[2], ".").concat(arr[3]), "".concat(arr[1], ".").concat(arr[0], ".").concat(arr[3], ".").concat(arr[2]), "".concat(arr[1], ".").concat(arr[2], ".").concat(arr[0], ".").concat(arr[3]), "".concat(arr[1], ".").concat(arr[2], ".").concat(arr[3], ".").concat(arr[0]), "".concat(arr[1], ".").concat(arr[3], ".").concat(arr[0], ".").concat(arr[2]), "".concat(arr[1], ".").concat(arr[3], ".").concat(arr[2], ".").concat(arr[0]), "".concat(arr[2], ".").concat(arr[0], ".").concat(arr[1], ".").concat(arr[3]), "".concat(arr[2], ".").concat(arr[0], ".").concat(arr[3], ".").concat(arr[1]), "".concat(arr[2], ".").concat(arr[1], ".").concat(arr[0], ".").concat(arr[3]), "".concat(arr[2], ".").concat(arr[1], ".").concat(arr[3], ".").concat(arr[0]), "".concat(arr[2], ".").concat(arr[3], ".").concat(arr[0], ".").concat(arr[1]), "".concat(arr[2], ".").concat(arr[3], ".").concat(arr[1], ".").concat(arr[0]), "".concat(arr[3], ".").concat(arr[0], ".").concat(arr[1], ".").concat(arr[2]), "".concat(arr[3], ".").concat(arr[0], ".").concat(arr[2], ".").concat(arr[1]), "".concat(arr[3], ".").concat(arr[1], ".").concat(arr[0], ".").concat(arr[2]), "".concat(arr[3], ".").concat(arr[1], ".").concat(arr[2], ".").concat(arr[0]), "".concat(arr[3], ".").concat(arr[2], ".").concat(arr[0], ".").concat(arr[1]), "".concat(arr[3], ".").concat(arr[2], ".").concat(arr[1], ".").concat(arr[0])];
|
1730 | }
|
1731 | }
|
1732 |
|
1733 | var classNameCombinations = {};
|
1734 |
|
1735 | function getClassNameCombinations(classNames) {
|
1736 | if (classNames.length === 0 || classNames.length === 1) return classNames;
|
1737 | var key = classNames.join('.');
|
1738 |
|
1739 | if (!classNameCombinations[key]) {
|
1740 | classNameCombinations[key] = powerSetPermutations(classNames);
|
1741 | }
|
1742 |
|
1743 | return classNameCombinations[key];
|
1744 | }
|
1745 |
|
1746 | function createStyleObject(classNames) {
|
1747 | var elementStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
1748 | var stylesheet = arguments.length > 2 ? arguments[2] : undefined;
|
1749 | var nonTokenClassNames = classNames.filter(function (className) {
|
1750 | return className !== 'token';
|
1751 | });
|
1752 | var classNamesCombinations = getClassNameCombinations(nonTokenClassNames);
|
1753 | return classNamesCombinations.reduce(function (styleObject, className) {
|
1754 | return _objectSpread({}, styleObject, stylesheet[className]);
|
1755 | }, elementStyle);
|
1756 | }
|
1757 |
|
1758 | function createClassNameString(classNames) {
|
1759 | return classNames.join(' ');
|
1760 | }
|
1761 |
|
1762 | function createChildren(stylesheet, useInlineStyles) {
|
1763 | var childrenCount = 0;
|
1764 | return function (children) {
|
1765 | childrenCount += 1;
|
1766 | return children.map(function (child, i) {
|
1767 | return createElement({
|
1768 | node: child,
|
1769 | stylesheet: stylesheet,
|
1770 | useInlineStyles: useInlineStyles,
|
1771 | key: "code-segment-".concat(childrenCount, "-").concat(i)
|
1772 | });
|
1773 | });
|
1774 | };
|
1775 | }
|
1776 |
|
1777 | function createElement(_ref) {
|
1778 | var node = _ref.node,
|
1779 | stylesheet = _ref.stylesheet,
|
1780 | _ref$style = _ref.style,
|
1781 | style = _ref$style === void 0 ? {} : _ref$style,
|
1782 | useInlineStyles = _ref.useInlineStyles,
|
1783 | key = _ref.key;
|
1784 | var properties = node.properties,
|
1785 | type = node.type,
|
1786 | TagName = node.tagName,
|
1787 | value = node.value;
|
1788 |
|
1789 | if (type === 'text') {
|
1790 | return value;
|
1791 | } else if (TagName) {
|
1792 | var childrenCreator = createChildren(stylesheet, useInlineStyles);
|
1793 | var props;
|
1794 |
|
1795 | if (!useInlineStyles) {
|
1796 | props = _objectSpread({}, properties, {
|
1797 | className: createClassNameString(properties.className)
|
1798 | });
|
1799 | } else {
|
1800 | var allStylesheetSelectors = Object.keys(stylesheet).reduce(function (classes, selector) {
|
1801 | selector.split('.').forEach(function (className) {
|
1802 | if (!classes.includes(className)) classes.push(className);
|
1803 | });
|
1804 | return classes;
|
1805 | }, []);
|
1806 |
|
1807 | var startingClassName = properties.className && properties.className.includes('token') ? ['token'] : [];
|
1808 | var className = properties.className && startingClassName.concat(properties.className.filter(function (className) {
|
1809 | return !allStylesheetSelectors.includes(className);
|
1810 | }));
|
1811 | props = _objectSpread({}, properties, {
|
1812 | className: createClassNameString(className) || undefined,
|
1813 | style: createStyleObject(properties.className, Object.assign({}, properties.style, style), stylesheet)
|
1814 | });
|
1815 | }
|
1816 |
|
1817 | var children = childrenCreator(node.children);
|
1818 | return React__default.createElement(TagName, _extends({
|
1819 | key: key
|
1820 | }, props), children);
|
1821 | }
|
1822 | }
|
1823 |
|
1824 | var checkForListedLanguage = function checkForListedLanguage(astGenerator, language) {
|
1825 | var langs = astGenerator.listLanguages();
|
1826 | return langs.indexOf(language) !== -1;
|
1827 | };
|
1828 |
|
1829 | var newLineRegex = /\n/g;
|
1830 |
|
1831 | function getNewLines(str) {
|
1832 | return str.match(newLineRegex);
|
1833 | }
|
1834 |
|
1835 | function getAllLineNumbers(_ref) {
|
1836 | var lines = _ref.lines,
|
1837 | startingLineNumber = _ref.startingLineNumber,
|
1838 | style = _ref.style;
|
1839 | return lines.map(function (_, i) {
|
1840 | var number = i + startingLineNumber;
|
1841 | return React__default.createElement("span", {
|
1842 | key: "line-".concat(i),
|
1843 | className: "react-syntax-highlighter-line-number",
|
1844 | style: typeof style === 'function' ? style(number) : style
|
1845 | }, "".concat(number, "\n"));
|
1846 | });
|
1847 | }
|
1848 |
|
1849 | function AllLineNumbers(_ref2) {
|
1850 | var codeString = _ref2.codeString,
|
1851 | codeStyle = _ref2.codeStyle,
|
1852 | _ref2$containerStyle = _ref2.containerStyle,
|
1853 | containerStyle = _ref2$containerStyle === void 0 ? {
|
1854 | float: 'left',
|
1855 | paddingRight: '10px'
|
1856 | } : _ref2$containerStyle,
|
1857 | _ref2$numberStyle = _ref2.numberStyle,
|
1858 | numberStyle = _ref2$numberStyle === void 0 ? {} : _ref2$numberStyle,
|
1859 | startingLineNumber = _ref2.startingLineNumber;
|
1860 | return React__default.createElement("code", {
|
1861 | style: Object.assign({}, codeStyle, containerStyle)
|
1862 | }, getAllLineNumbers({
|
1863 | lines: codeString.replace(/\n$/, '').split('\n'),
|
1864 | style: numberStyle,
|
1865 | startingLineNumber: startingLineNumber
|
1866 | }));
|
1867 | }
|
1868 |
|
1869 | function getEmWidthOfNumber(num) {
|
1870 | return "".concat(num.toString().length, ".25em");
|
1871 | }
|
1872 |
|
1873 | function getInlineLineNumber(lineNumber, inlineLineNumberStyle) {
|
1874 | return {
|
1875 | type: 'element',
|
1876 | tagName: 'span',
|
1877 | properties: {
|
1878 | key: "line-number--".concat(lineNumber),
|
1879 | className: ['comment', 'linenumber', 'react-syntax-highlighter-line-number'],
|
1880 | style: inlineLineNumberStyle
|
1881 | },
|
1882 | children: [{
|
1883 | type: 'text',
|
1884 | value: lineNumber
|
1885 | }]
|
1886 | };
|
1887 | }
|
1888 |
|
1889 | function assembleLineNumberStyles(lineNumberStyle, lineNumber, largestLineNumber) {
|
1890 |
|
1891 | var defaultLineNumberStyle = {
|
1892 | display: 'inline-block',
|
1893 | minWidth: getEmWidthOfNumber(largestLineNumber),
|
1894 | paddingRight: '1em',
|
1895 | textAlign: 'right',
|
1896 | userSelect: 'none'
|
1897 | };
|
1898 |
|
1899 | var customLineNumberStyle = typeof lineNumberStyle === 'function' ? lineNumberStyle(lineNumber) : lineNumberStyle;
|
1900 |
|
1901 | var assembledStyle = _objectSpread({}, defaultLineNumberStyle, customLineNumberStyle);
|
1902 |
|
1903 | return assembledStyle;
|
1904 | }
|
1905 |
|
1906 | function createLineElement(_ref3) {
|
1907 | var children = _ref3.children,
|
1908 | lineNumber = _ref3.lineNumber,
|
1909 | lineNumberStyle = _ref3.lineNumberStyle,
|
1910 | largestLineNumber = _ref3.largestLineNumber,
|
1911 | showInlineLineNumbers = _ref3.showInlineLineNumbers,
|
1912 | _ref3$lineProps = _ref3.lineProps,
|
1913 | lineProps = _ref3$lineProps === void 0 ? {} : _ref3$lineProps,
|
1914 | _ref3$className = _ref3.className,
|
1915 | className = _ref3$className === void 0 ? [] : _ref3$className,
|
1916 | showLineNumbers = _ref3.showLineNumbers,
|
1917 | wrapLongLines = _ref3.wrapLongLines;
|
1918 | var properties = typeof lineProps === 'function' ? lineProps(lineNumber) : lineProps;
|
1919 | properties['className'] = className;
|
1920 |
|
1921 | if (lineNumber && showInlineLineNumbers) {
|
1922 | var inlineLineNumberStyle = assembleLineNumberStyles(lineNumberStyle, lineNumber, largestLineNumber);
|
1923 | children.unshift(getInlineLineNumber(lineNumber, inlineLineNumberStyle));
|
1924 | }
|
1925 |
|
1926 | if (wrapLongLines & showLineNumbers) {
|
1927 | properties.style = _objectSpread({}, properties.style, {
|
1928 | display: 'flex'
|
1929 | });
|
1930 | }
|
1931 |
|
1932 | return {
|
1933 | type: 'element',
|
1934 | tagName: 'span',
|
1935 | properties: properties,
|
1936 | children: children
|
1937 | };
|
1938 | }
|
1939 |
|
1940 | function flattenCodeTree(tree) {
|
1941 | var className = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
1942 | var newTree = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
1943 |
|
1944 | for (var i = 0; i < tree.length; i++) {
|
1945 | var node = tree[i];
|
1946 |
|
1947 | if (node.type === 'text') {
|
1948 | newTree.push(createLineElement({
|
1949 | children: [node],
|
1950 | className: _toConsumableArray(new Set(className))
|
1951 | }));
|
1952 | } else if (node.children) {
|
1953 | var classNames = className.concat(node.properties.className);
|
1954 | newTree = newTree.concat(flattenCodeTree(node.children, classNames));
|
1955 | }
|
1956 | }
|
1957 |
|
1958 | return newTree;
|
1959 | }
|
1960 |
|
1961 | function processLines(codeTree, wrapLines, lineProps, showLineNumbers, showInlineLineNumbers, startingLineNumber, largestLineNumber, lineNumberStyle, wrapLongLines) {
|
1962 | var _ref4;
|
1963 |
|
1964 | var tree = flattenCodeTree(codeTree.value);
|
1965 | var newTree = [];
|
1966 | var lastLineBreakIndex = -1;
|
1967 | var index = 0;
|
1968 |
|
1969 | function createWrappedLine(children, lineNumber) {
|
1970 | var className = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
1971 | return createLineElement({
|
1972 | children: children,
|
1973 | lineNumber: lineNumber,
|
1974 | lineNumberStyle: lineNumberStyle,
|
1975 | largestLineNumber: largestLineNumber,
|
1976 | showInlineLineNumbers: showInlineLineNumbers,
|
1977 | lineProps: lineProps,
|
1978 | className: className,
|
1979 | showLineNumbers: showLineNumbers,
|
1980 | wrapLongLines: wrapLongLines
|
1981 | });
|
1982 | }
|
1983 |
|
1984 | function createUnwrappedLine(children, lineNumber) {
|
1985 | if (showLineNumbers && lineNumber && showInlineLineNumbers) {
|
1986 | var inlineLineNumberStyle = assembleLineNumberStyles(lineNumberStyle, lineNumber, largestLineNumber);
|
1987 | children.unshift(getInlineLineNumber(lineNumber, inlineLineNumberStyle));
|
1988 | }
|
1989 |
|
1990 | return children;
|
1991 | }
|
1992 |
|
1993 | function createLine(children, lineNumber) {
|
1994 | var className = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
1995 | return wrapLines || className.length > 0 ? createWrappedLine(children, lineNumber, className) : createUnwrappedLine(children, lineNumber);
|
1996 | }
|
1997 |
|
1998 | var _loop = function _loop() {
|
1999 | var node = tree[index];
|
2000 | var value = node.children[0].value;
|
2001 | var newLines = getNewLines(value);
|
2002 |
|
2003 | if (newLines) {
|
2004 | var splitValue = value.split('\n');
|
2005 | splitValue.forEach(function (text, i) {
|
2006 | var lineNumber = showLineNumbers && newTree.length + startingLineNumber;
|
2007 | var newChild = {
|
2008 | type: 'text',
|
2009 | value: "".concat(text, "\n")
|
2010 | };
|
2011 |
|
2012 | if (i === 0) {
|
2013 | var _children = tree.slice(lastLineBreakIndex + 1, index).concat(createLineElement({
|
2014 | children: [newChild],
|
2015 | className: node.properties.className
|
2016 | }));
|
2017 |
|
2018 | var _line = createLine(_children, lineNumber);
|
2019 |
|
2020 | newTree.push(_line);
|
2021 | } else if (i === splitValue.length - 1) {
|
2022 | var stringChild = tree[index + 1] && tree[index + 1].children && tree[index + 1].children[0];
|
2023 |
|
2024 | if (stringChild) {
|
2025 | var lastLineInPreviousSpan = {
|
2026 | type: 'text',
|
2027 | value: "".concat(text)
|
2028 | };
|
2029 | var newElem = createLineElement({
|
2030 | children: [lastLineInPreviousSpan],
|
2031 | className: node.properties.className
|
2032 | });
|
2033 | tree.splice(index + 1, 0, newElem);
|
2034 | } else {
|
2035 | var _children2 = [newChild];
|
2036 |
|
2037 | var _line2 = createLine(_children2, lineNumber, node.properties.className);
|
2038 |
|
2039 | newTree.push(_line2);
|
2040 | }
|
2041 |
|
2042 | } else {
|
2043 | var _children3 = [newChild];
|
2044 |
|
2045 | var _line3 = createLine(_children3, lineNumber, node.properties.className);
|
2046 |
|
2047 | newTree.push(_line3);
|
2048 | }
|
2049 | });
|
2050 | lastLineBreakIndex = index;
|
2051 | }
|
2052 |
|
2053 | index++;
|
2054 | };
|
2055 |
|
2056 | while (index < tree.length) {
|
2057 | _loop();
|
2058 | }
|
2059 |
|
2060 | if (lastLineBreakIndex !== tree.length - 1) {
|
2061 | var children = tree.slice(lastLineBreakIndex + 1, tree.length);
|
2062 |
|
2063 | if (children && children.length) {
|
2064 | var lineNumber = showLineNumbers && newTree.length + startingLineNumber;
|
2065 | var line = createLine(children, lineNumber);
|
2066 | newTree.push(line);
|
2067 | }
|
2068 | }
|
2069 |
|
2070 | return wrapLines ? newTree : (_ref4 = []).concat.apply(_ref4, newTree);
|
2071 | }
|
2072 |
|
2073 | function defaultRenderer(_ref5) {
|
2074 | var rows = _ref5.rows,
|
2075 | stylesheet = _ref5.stylesheet,
|
2076 | useInlineStyles = _ref5.useInlineStyles;
|
2077 | return rows.map(function (node, i) {
|
2078 | return createElement({
|
2079 | node: node,
|
2080 | stylesheet: stylesheet,
|
2081 | useInlineStyles: useInlineStyles,
|
2082 | key: "code-segement".concat(i)
|
2083 | });
|
2084 | });
|
2085 | }
|
2086 |
|
2087 |
|
2088 | function isHighlightJs(astGenerator) {
|
2089 | return astGenerator && typeof astGenerator.highlightAuto !== 'undefined';
|
2090 | }
|
2091 |
|
2092 | function getCodeTree(_ref6) {
|
2093 | var astGenerator = _ref6.astGenerator,
|
2094 | language = _ref6.language,
|
2095 | code = _ref6.code,
|
2096 | defaultCodeValue = _ref6.defaultCodeValue;
|
2097 |
|
2098 |
|
2099 |
|
2100 | if (isHighlightJs(astGenerator)) {
|
2101 | var hasLanguage = checkForListedLanguage(astGenerator, language);
|
2102 |
|
2103 | if (language === 'text') {
|
2104 | return {
|
2105 | value: defaultCodeValue,
|
2106 | language: 'text'
|
2107 | };
|
2108 | } else if (hasLanguage) {
|
2109 | return astGenerator.highlight(language, code);
|
2110 | } else {
|
2111 | return astGenerator.highlightAuto(code);
|
2112 | }
|
2113 | }
|
2114 |
|
2115 |
|
2116 | try {
|
2117 | return language && language !== 'text' ? {
|
2118 | value: astGenerator.highlight(code, language)
|
2119 | } : {
|
2120 | value: defaultCodeValue
|
2121 | };
|
2122 | } catch (e) {
|
2123 | return {
|
2124 | value: defaultCodeValue
|
2125 | };
|
2126 | }
|
2127 | }
|
2128 |
|
2129 | function highlight$1(defaultAstGenerator, defaultStyle) {
|
2130 | return function SyntaxHighlighter(_ref7) {
|
2131 | var language = _ref7.language,
|
2132 | children = _ref7.children,
|
2133 | _ref7$style = _ref7.style,
|
2134 | style = _ref7$style === void 0 ? defaultStyle : _ref7$style,
|
2135 | _ref7$customStyle = _ref7.customStyle,
|
2136 | customStyle = _ref7$customStyle === void 0 ? {} : _ref7$customStyle,
|
2137 | _ref7$codeTagProps = _ref7.codeTagProps,
|
2138 | codeTagProps = _ref7$codeTagProps === void 0 ? {
|
2139 | className: language ? "language-".concat(language) : undefined,
|
2140 | style: _objectSpread({}, style['code[class*="language-"]'], style["code[class*=\"language-".concat(language, "\"]")])
|
2141 | } : _ref7$codeTagProps,
|
2142 | _ref7$useInlineStyles = _ref7.useInlineStyles,
|
2143 | useInlineStyles = _ref7$useInlineStyles === void 0 ? true : _ref7$useInlineStyles,
|
2144 | _ref7$showLineNumbers = _ref7.showLineNumbers,
|
2145 | showLineNumbers = _ref7$showLineNumbers === void 0 ? false : _ref7$showLineNumbers,
|
2146 | _ref7$showInlineLineN = _ref7.showInlineLineNumbers,
|
2147 | showInlineLineNumbers = _ref7$showInlineLineN === void 0 ? true : _ref7$showInlineLineN,
|
2148 | _ref7$startingLineNum = _ref7.startingLineNumber,
|
2149 | startingLineNumber = _ref7$startingLineNum === void 0 ? 1 : _ref7$startingLineNum,
|
2150 | lineNumberContainerStyle = _ref7.lineNumberContainerStyle,
|
2151 | _ref7$lineNumberStyle = _ref7.lineNumberStyle,
|
2152 | lineNumberStyle = _ref7$lineNumberStyle === void 0 ? {} : _ref7$lineNumberStyle,
|
2153 | wrapLines = _ref7.wrapLines,
|
2154 | _ref7$wrapLongLines = _ref7.wrapLongLines,
|
2155 | wrapLongLines = _ref7$wrapLongLines === void 0 ? false : _ref7$wrapLongLines,
|
2156 | _ref7$lineProps = _ref7.lineProps,
|
2157 | lineProps = _ref7$lineProps === void 0 ? {} : _ref7$lineProps,
|
2158 | renderer = _ref7.renderer,
|
2159 | _ref7$PreTag = _ref7.PreTag,
|
2160 | PreTag = _ref7$PreTag === void 0 ? 'pre' : _ref7$PreTag,
|
2161 | _ref7$CodeTag = _ref7.CodeTag,
|
2162 | CodeTag = _ref7$CodeTag === void 0 ? 'code' : _ref7$CodeTag,
|
2163 | _ref7$code = _ref7.code,
|
2164 | code = _ref7$code === void 0 ? Array.isArray(children) ? children[0] : children : _ref7$code,
|
2165 | astGenerator = _ref7.astGenerator,
|
2166 | rest = _objectWithoutProperties(_ref7, ["language", "children", "style", "customStyle", "codeTagProps", "useInlineStyles", "showLineNumbers", "showInlineLineNumbers", "startingLineNumber", "lineNumberContainerStyle", "lineNumberStyle", "wrapLines", "wrapLongLines", "lineProps", "renderer", "PreTag", "CodeTag", "code", "astGenerator"]);
|
2167 |
|
2168 | astGenerator = astGenerator || defaultAstGenerator;
|
2169 | var allLineNumbers = showLineNumbers ? React__default.createElement(AllLineNumbers, {
|
2170 | containerStyle: lineNumberContainerStyle,
|
2171 | codeStyle: codeTagProps.style || {},
|
2172 | numberStyle: lineNumberStyle,
|
2173 | startingLineNumber: startingLineNumber,
|
2174 | codeString: code
|
2175 | }) : null;
|
2176 | var defaultPreStyle = style.hljs || style['pre[class*="language-"]'] || {
|
2177 | backgroundColor: '#fff'
|
2178 | };
|
2179 | var generatorClassName = isHighlightJs(astGenerator) ? 'hljs' : 'prismjs';
|
2180 | var preProps = useInlineStyles ? Object.assign({}, rest, {
|
2181 | style: Object.assign({}, defaultPreStyle, customStyle)
|
2182 | }) : Object.assign({}, rest, {
|
2183 | className: rest.className ? "".concat(generatorClassName, " ").concat(rest.className) : generatorClassName,
|
2184 | style: Object.assign({}, customStyle)
|
2185 | });
|
2186 |
|
2187 | if (!astGenerator) {
|
2188 | return React__default.createElement(PreTag, preProps, allLineNumbers, React__default.createElement(CodeTag, codeTagProps, code));
|
2189 | }
|
2190 | |
2191 |
|
2192 |
|
2193 |
|
2194 |
|
2195 |
|
2196 | if (wrapLines === undefined && renderer || wrapLongLines) wrapLines = true;
|
2197 | renderer = renderer || defaultRenderer;
|
2198 | var defaultCodeValue = [{
|
2199 | type: 'text',
|
2200 | value: code
|
2201 | }];
|
2202 | var codeTree = getCodeTree({
|
2203 | astGenerator: astGenerator,
|
2204 | language: language,
|
2205 | code: code,
|
2206 | defaultCodeValue: defaultCodeValue
|
2207 | });
|
2208 |
|
2209 | if (codeTree.language === null) {
|
2210 | codeTree.value = defaultCodeValue;
|
2211 | }
|
2212 |
|
2213 |
|
2214 | var largestLineNumber = codeTree.value.length + startingLineNumber;
|
2215 | var rows = processLines(codeTree, wrapLines, lineProps, showLineNumbers, showInlineLineNumbers, startingLineNumber, largestLineNumber, lineNumberStyle, wrapLongLines);
|
2216 |
|
2217 | if (wrapLongLines) {
|
2218 | codeTagProps.style = _objectSpread({}, codeTagProps.style, {
|
2219 | whiteSpace: 'pre-wrap'
|
2220 | });
|
2221 | } else {
|
2222 | codeTagProps.style = _objectSpread({}, codeTagProps.style, {
|
2223 | whiteSpace: 'pre'
|
2224 | });
|
2225 | }
|
2226 |
|
2227 | return React__default.createElement(PreTag, preProps, React__default.createElement(CodeTag, codeTagProps, !showInlineLineNumbers && allLineNumbers, renderer({
|
2228 | rows: rows,
|
2229 | stylesheet: style,
|
2230 | useInlineStyles: useInlineStyles
|
2231 | })));
|
2232 | };
|
2233 | }
|
2234 |
|
2235 | var immutable = extend;
|
2236 | var hasOwnProperty = Object.prototype.hasOwnProperty;
|
2237 |
|
2238 | function extend() {
|
2239 | var target = {};
|
2240 |
|
2241 | for (var i = 0; i < arguments.length; i++) {
|
2242 | var source = arguments[i];
|
2243 |
|
2244 | for (var key in source) {
|
2245 | if (hasOwnProperty.call(source, key)) {
|
2246 | target[key] = source[key];
|
2247 | }
|
2248 | }
|
2249 | }
|
2250 |
|
2251 | return target;
|
2252 | }
|
2253 |
|
2254 | var schema$1 = Schema$2;
|
2255 | var proto$1 = Schema$2.prototype;
|
2256 | proto$1.space = null;
|
2257 | proto$1.normal = {};
|
2258 | proto$1.property = {};
|
2259 |
|
2260 | function Schema$2(property, normal, space) {
|
2261 | this.property = property;
|
2262 | this.normal = normal;
|
2263 |
|
2264 | if (space) {
|
2265 | this.space = space;
|
2266 | }
|
2267 | }
|
2268 |
|
2269 | var xtend = immutable;
|
2270 | var Schema$1 = schema$1;
|
2271 | var merge_1 = merge$1;
|
2272 |
|
2273 | function merge$1(definitions) {
|
2274 | var length = definitions.length;
|
2275 | var property = [];
|
2276 | var normal = [];
|
2277 | var index = -1;
|
2278 | var info;
|
2279 | var space;
|
2280 |
|
2281 | while (++index < length) {
|
2282 | info = definitions[index];
|
2283 | property.push(info.property);
|
2284 | normal.push(info.normal);
|
2285 | space = info.space;
|
2286 | }
|
2287 |
|
2288 | return new Schema$1(xtend.apply(null, property), xtend.apply(null, normal), space);
|
2289 | }
|
2290 |
|
2291 | var normalize_1 = normalize$3;
|
2292 |
|
2293 | function normalize$3(value) {
|
2294 | return value.toLowerCase();
|
2295 | }
|
2296 |
|
2297 | var info = Info$2;
|
2298 | var proto = Info$2.prototype;
|
2299 | proto.space = null;
|
2300 | proto.attribute = null;
|
2301 | proto.property = null;
|
2302 | proto.boolean = false;
|
2303 | proto.booleanish = false;
|
2304 | proto.overloadedBoolean = false;
|
2305 | proto.number = false;
|
2306 | proto.commaSeparated = false;
|
2307 | proto.spaceSeparated = false;
|
2308 | proto.commaOrSpaceSeparated = false;
|
2309 | proto.mustUseProperty = false;
|
2310 | proto.defined = false;
|
2311 |
|
2312 | function Info$2(property, attribute) {
|
2313 | this.property = property;
|
2314 | this.attribute = attribute;
|
2315 | }
|
2316 |
|
2317 | var types$3 = {};
|
2318 | var powers = 0;
|
2319 | types$3.boolean = increment();
|
2320 | types$3.booleanish = increment();
|
2321 | types$3.overloadedBoolean = increment();
|
2322 | types$3.number = increment();
|
2323 | types$3.spaceSeparated = increment();
|
2324 | types$3.commaSeparated = increment();
|
2325 | types$3.commaOrSpaceSeparated = increment();
|
2326 |
|
2327 | function increment() {
|
2328 | return Math.pow(2, ++powers);
|
2329 | }
|
2330 |
|
2331 | var Info$1 = info;
|
2332 | var types$2 = types$3;
|
2333 | var definedInfo = DefinedInfo$2;
|
2334 | DefinedInfo$2.prototype = new Info$1();
|
2335 | DefinedInfo$2.prototype.defined = true;
|
2336 | var checks = ['boolean', 'booleanish', 'overloadedBoolean', 'number', 'commaSeparated', 'spaceSeparated', 'commaOrSpaceSeparated'];
|
2337 | var checksLength = checks.length;
|
2338 |
|
2339 | function DefinedInfo$2(property, attribute, mask, space) {
|
2340 | var index = -1;
|
2341 | var check;
|
2342 | mark(this, 'space', space);
|
2343 | Info$1.call(this, property, attribute);
|
2344 |
|
2345 | while (++index < checksLength) {
|
2346 | check = checks[index];
|
2347 | mark(this, check, (mask & types$2[check]) === types$2[check]);
|
2348 | }
|
2349 | }
|
2350 |
|
2351 | function mark(values, key, value) {
|
2352 | if (value) {
|
2353 | values[key] = value;
|
2354 | }
|
2355 | }
|
2356 |
|
2357 | var normalize$2 = normalize_1;
|
2358 | var Schema = schema$1;
|
2359 | var DefinedInfo$1 = definedInfo;
|
2360 | var create_1 = create$5;
|
2361 |
|
2362 | function create$5(definition) {
|
2363 | var space = definition.space;
|
2364 | var mustUseProperty = definition.mustUseProperty || [];
|
2365 | var attributes = definition.attributes || {};
|
2366 | var props = definition.properties;
|
2367 | var transform = definition.transform;
|
2368 | var property = {};
|
2369 | var normal = {};
|
2370 | var prop;
|
2371 | var info;
|
2372 |
|
2373 | for (prop in props) {
|
2374 | info = new DefinedInfo$1(prop, transform(attributes, prop), props[prop], space);
|
2375 |
|
2376 | if (mustUseProperty.indexOf(prop) !== -1) {
|
2377 | info.mustUseProperty = true;
|
2378 | }
|
2379 |
|
2380 | property[prop] = info;
|
2381 | normal[normalize$2(prop)] = prop;
|
2382 | normal[normalize$2(info.attribute)] = prop;
|
2383 | }
|
2384 |
|
2385 | return new Schema(property, normal, space);
|
2386 | }
|
2387 |
|
2388 | var create$4 = create_1;
|
2389 | var xlink$1 = create$4({
|
2390 | space: 'xlink',
|
2391 | transform: xlinkTransform,
|
2392 | properties: {
|
2393 | xLinkActuate: null,
|
2394 | xLinkArcRole: null,
|
2395 | xLinkHref: null,
|
2396 | xLinkRole: null,
|
2397 | xLinkShow: null,
|
2398 | xLinkTitle: null,
|
2399 | xLinkType: null
|
2400 | }
|
2401 | });
|
2402 |
|
2403 | function xlinkTransform(_, prop) {
|
2404 | return 'xlink:' + prop.slice(5).toLowerCase();
|
2405 | }
|
2406 |
|
2407 | var create$3 = create_1;
|
2408 | var xml$1 = create$3({
|
2409 | space: 'xml',
|
2410 | transform: xmlTransform,
|
2411 | properties: {
|
2412 | xmlLang: null,
|
2413 | xmlBase: null,
|
2414 | xmlSpace: null
|
2415 | }
|
2416 | });
|
2417 |
|
2418 | function xmlTransform(_, prop) {
|
2419 | return 'xml:' + prop.slice(3).toLowerCase();
|
2420 | }
|
2421 |
|
2422 | var caseSensitiveTransform_1 = caseSensitiveTransform$1;
|
2423 |
|
2424 | function caseSensitiveTransform$1(attributes, attribute) {
|
2425 | return attribute in attributes ? attributes[attribute] : attribute;
|
2426 | }
|
2427 |
|
2428 | var caseSensitiveTransform = caseSensitiveTransform_1;
|
2429 | var caseInsensitiveTransform_1 = caseInsensitiveTransform$2;
|
2430 |
|
2431 | function caseInsensitiveTransform$2(attributes, property) {
|
2432 | return caseSensitiveTransform(attributes, property.toLowerCase());
|
2433 | }
|
2434 |
|
2435 | var create$2 = create_1;
|
2436 | var caseInsensitiveTransform$1 = caseInsensitiveTransform_1;
|
2437 | var xmlns$1 = create$2({
|
2438 | space: 'xmlns',
|
2439 | attributes: {
|
2440 | xmlnsxlink: 'xmlns:xlink'
|
2441 | },
|
2442 | transform: caseInsensitiveTransform$1,
|
2443 | properties: {
|
2444 | xmlns: null,
|
2445 | xmlnsXLink: null
|
2446 | }
|
2447 | });
|
2448 | var types$1 = types$3;
|
2449 | var create$1 = create_1;
|
2450 | var booleanish$1 = types$1.booleanish;
|
2451 | var number$1 = types$1.number;
|
2452 | var spaceSeparated$1 = types$1.spaceSeparated;
|
2453 | var aria$1 = create$1({
|
2454 | transform: ariaTransform,
|
2455 | properties: {
|
2456 | ariaActiveDescendant: null,
|
2457 | ariaAtomic: booleanish$1,
|
2458 | ariaAutoComplete: null,
|
2459 | ariaBusy: booleanish$1,
|
2460 | ariaChecked: booleanish$1,
|
2461 | ariaColCount: number$1,
|
2462 | ariaColIndex: number$1,
|
2463 | ariaColSpan: number$1,
|
2464 | ariaControls: spaceSeparated$1,
|
2465 | ariaCurrent: null,
|
2466 | ariaDescribedBy: spaceSeparated$1,
|
2467 | ariaDetails: null,
|
2468 | ariaDisabled: booleanish$1,
|
2469 | ariaDropEffect: spaceSeparated$1,
|
2470 | ariaErrorMessage: null,
|
2471 | ariaExpanded: booleanish$1,
|
2472 | ariaFlowTo: spaceSeparated$1,
|
2473 | ariaGrabbed: booleanish$1,
|
2474 | ariaHasPopup: null,
|
2475 | ariaHidden: booleanish$1,
|
2476 | ariaInvalid: null,
|
2477 | ariaKeyShortcuts: null,
|
2478 | ariaLabel: null,
|
2479 | ariaLabelledBy: spaceSeparated$1,
|
2480 | ariaLevel: number$1,
|
2481 | ariaLive: null,
|
2482 | ariaModal: booleanish$1,
|
2483 | ariaMultiLine: booleanish$1,
|
2484 | ariaMultiSelectable: booleanish$1,
|
2485 | ariaOrientation: null,
|
2486 | ariaOwns: spaceSeparated$1,
|
2487 | ariaPlaceholder: null,
|
2488 | ariaPosInSet: number$1,
|
2489 | ariaPressed: booleanish$1,
|
2490 | ariaReadOnly: booleanish$1,
|
2491 | ariaRelevant: null,
|
2492 | ariaRequired: booleanish$1,
|
2493 | ariaRoleDescription: spaceSeparated$1,
|
2494 | ariaRowCount: number$1,
|
2495 | ariaRowIndex: number$1,
|
2496 | ariaRowSpan: number$1,
|
2497 | ariaSelected: booleanish$1,
|
2498 | ariaSetSize: number$1,
|
2499 | ariaSort: null,
|
2500 | ariaValueMax: number$1,
|
2501 | ariaValueMin: number$1,
|
2502 | ariaValueNow: number$1,
|
2503 | ariaValueText: null,
|
2504 | role: null
|
2505 | }
|
2506 | });
|
2507 |
|
2508 | function ariaTransform(_, prop) {
|
2509 | return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase();
|
2510 | }
|
2511 |
|
2512 | var types = types$3;
|
2513 | var create = create_1;
|
2514 | var caseInsensitiveTransform = caseInsensitiveTransform_1;
|
2515 | var boolean = types.boolean;
|
2516 | var overloadedBoolean = types.overloadedBoolean;
|
2517 | var booleanish = types.booleanish;
|
2518 | var number = types.number;
|
2519 | var spaceSeparated = types.spaceSeparated;
|
2520 | var commaSeparated = types.commaSeparated;
|
2521 | var html$2 = create({
|
2522 | space: 'html',
|
2523 | attributes: {
|
2524 | acceptcharset: 'accept-charset',
|
2525 | classname: 'class',
|
2526 | htmlfor: 'for',
|
2527 | httpequiv: 'http-equiv'
|
2528 | },
|
2529 | transform: caseInsensitiveTransform,
|
2530 | mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],
|
2531 | properties: {
|
2532 |
|
2533 | abbr: null,
|
2534 | accept: commaSeparated,
|
2535 | acceptCharset: spaceSeparated,
|
2536 | accessKey: spaceSeparated,
|
2537 | action: null,
|
2538 | allow: null,
|
2539 | allowFullScreen: boolean,
|
2540 | allowPaymentRequest: boolean,
|
2541 | allowUserMedia: boolean,
|
2542 | alt: null,
|
2543 | as: null,
|
2544 | async: boolean,
|
2545 | autoCapitalize: null,
|
2546 | autoComplete: spaceSeparated,
|
2547 | autoFocus: boolean,
|
2548 | autoPlay: boolean,
|
2549 | capture: boolean,
|
2550 | charSet: null,
|
2551 | checked: boolean,
|
2552 | cite: null,
|
2553 | className: spaceSeparated,
|
2554 | cols: number,
|
2555 | colSpan: null,
|
2556 | content: null,
|
2557 | contentEditable: booleanish,
|
2558 | controls: boolean,
|
2559 | controlsList: spaceSeparated,
|
2560 | coords: number | commaSeparated,
|
2561 | crossOrigin: null,
|
2562 | data: null,
|
2563 | dateTime: null,
|
2564 | decoding: null,
|
2565 | default: boolean,
|
2566 | defer: boolean,
|
2567 | dir: null,
|
2568 | dirName: null,
|
2569 | disabled: boolean,
|
2570 | download: overloadedBoolean,
|
2571 | draggable: booleanish,
|
2572 | encType: null,
|
2573 | enterKeyHint: null,
|
2574 | form: null,
|
2575 | formAction: null,
|
2576 | formEncType: null,
|
2577 | formMethod: null,
|
2578 | formNoValidate: boolean,
|
2579 | formTarget: null,
|
2580 | headers: spaceSeparated,
|
2581 | height: number,
|
2582 | hidden: boolean,
|
2583 | high: number,
|
2584 | href: null,
|
2585 | hrefLang: null,
|
2586 | htmlFor: spaceSeparated,
|
2587 | httpEquiv: spaceSeparated,
|
2588 | id: null,
|
2589 | imageSizes: null,
|
2590 | imageSrcSet: commaSeparated,
|
2591 | inputMode: null,
|
2592 | integrity: null,
|
2593 | is: null,
|
2594 | isMap: boolean,
|
2595 | itemId: null,
|
2596 | itemProp: spaceSeparated,
|
2597 | itemRef: spaceSeparated,
|
2598 | itemScope: boolean,
|
2599 | itemType: spaceSeparated,
|
2600 | kind: null,
|
2601 | label: null,
|
2602 | lang: null,
|
2603 | language: null,
|
2604 | list: null,
|
2605 | loading: null,
|
2606 | loop: boolean,
|
2607 | low: number,
|
2608 | manifest: null,
|
2609 | max: null,
|
2610 | maxLength: number,
|
2611 | media: null,
|
2612 | method: null,
|
2613 | min: null,
|
2614 | minLength: number,
|
2615 | multiple: boolean,
|
2616 | muted: boolean,
|
2617 | name: null,
|
2618 | nonce: null,
|
2619 | noModule: boolean,
|
2620 | noValidate: boolean,
|
2621 | onAbort: null,
|
2622 | onAfterPrint: null,
|
2623 | onAuxClick: null,
|
2624 | onBeforePrint: null,
|
2625 | onBeforeUnload: null,
|
2626 | onBlur: null,
|
2627 | onCancel: null,
|
2628 | onCanPlay: null,
|
2629 | onCanPlayThrough: null,
|
2630 | onChange: null,
|
2631 | onClick: null,
|
2632 | onClose: null,
|
2633 | onContextMenu: null,
|
2634 | onCopy: null,
|
2635 | onCueChange: null,
|
2636 | onCut: null,
|
2637 | onDblClick: null,
|
2638 | onDrag: null,
|
2639 | onDragEnd: null,
|
2640 | onDragEnter: null,
|
2641 | onDragExit: null,
|
2642 | onDragLeave: null,
|
2643 | onDragOver: null,
|
2644 | onDragStart: null,
|
2645 | onDrop: null,
|
2646 | onDurationChange: null,
|
2647 | onEmptied: null,
|
2648 | onEnded: null,
|
2649 | onError: null,
|
2650 | onFocus: null,
|
2651 | onFormData: null,
|
2652 | onHashChange: null,
|
2653 | onInput: null,
|
2654 | onInvalid: null,
|
2655 | onKeyDown: null,
|
2656 | onKeyPress: null,
|
2657 | onKeyUp: null,
|
2658 | onLanguageChange: null,
|
2659 | onLoad: null,
|
2660 | onLoadedData: null,
|
2661 | onLoadedMetadata: null,
|
2662 | onLoadEnd: null,
|
2663 | onLoadStart: null,
|
2664 | onMessage: null,
|
2665 | onMessageError: null,
|
2666 | onMouseDown: null,
|
2667 | onMouseEnter: null,
|
2668 | onMouseLeave: null,
|
2669 | onMouseMove: null,
|
2670 | onMouseOut: null,
|
2671 | onMouseOver: null,
|
2672 | onMouseUp: null,
|
2673 | onOffline: null,
|
2674 | onOnline: null,
|
2675 | onPageHide: null,
|
2676 | onPageShow: null,
|
2677 | onPaste: null,
|
2678 | onPause: null,
|
2679 | onPlay: null,
|
2680 | onPlaying: null,
|
2681 | onPopState: null,
|
2682 | onProgress: null,
|
2683 | onRateChange: null,
|
2684 | onRejectionHandled: null,
|
2685 | onReset: null,
|
2686 | onResize: null,
|
2687 | onScroll: null,
|
2688 | onSecurityPolicyViolation: null,
|
2689 | onSeeked: null,
|
2690 | onSeeking: null,
|
2691 | onSelect: null,
|
2692 | onSlotChange: null,
|
2693 | onStalled: null,
|
2694 | onStorage: null,
|
2695 | onSubmit: null,
|
2696 | onSuspend: null,
|
2697 | onTimeUpdate: null,
|
2698 | onToggle: null,
|
2699 | onUnhandledRejection: null,
|
2700 | onUnload: null,
|
2701 | onVolumeChange: null,
|
2702 | onWaiting: null,
|
2703 | onWheel: null,
|
2704 | open: boolean,
|
2705 | optimum: number,
|
2706 | pattern: null,
|
2707 | ping: spaceSeparated,
|
2708 | placeholder: null,
|
2709 | playsInline: boolean,
|
2710 | poster: null,
|
2711 | preload: null,
|
2712 | readOnly: boolean,
|
2713 | referrerPolicy: null,
|
2714 | rel: spaceSeparated,
|
2715 | required: boolean,
|
2716 | reversed: boolean,
|
2717 | rows: number,
|
2718 | rowSpan: number,
|
2719 | sandbox: spaceSeparated,
|
2720 | scope: null,
|
2721 | scoped: boolean,
|
2722 | seamless: boolean,
|
2723 | selected: boolean,
|
2724 | shape: null,
|
2725 | size: number,
|
2726 | sizes: null,
|
2727 | slot: null,
|
2728 | span: number,
|
2729 | spellCheck: booleanish,
|
2730 | src: null,
|
2731 | srcDoc: null,
|
2732 | srcLang: null,
|
2733 | srcSet: commaSeparated,
|
2734 | start: number,
|
2735 | step: null,
|
2736 | style: null,
|
2737 | tabIndex: number,
|
2738 | target: null,
|
2739 | title: null,
|
2740 | translate: null,
|
2741 | type: null,
|
2742 | typeMustMatch: boolean,
|
2743 | useMap: null,
|
2744 | value: booleanish,
|
2745 | width: number,
|
2746 | wrap: null,
|
2747 |
|
2748 |
|
2749 | align: null,
|
2750 |
|
2751 | aLink: null,
|
2752 |
|
2753 | archive: spaceSeparated,
|
2754 |
|
2755 | axis: null,
|
2756 |
|
2757 | background: null,
|
2758 |
|
2759 | bgColor: null,
|
2760 |
|
2761 | border: number,
|
2762 |
|
2763 | borderColor: null,
|
2764 |
|
2765 | bottomMargin: number,
|
2766 |
|
2767 | cellPadding: null,
|
2768 |
|
2769 | cellSpacing: null,
|
2770 |
|
2771 | char: null,
|
2772 |
|
2773 | charOff: null,
|
2774 |
|
2775 | classId: null,
|
2776 |
|
2777 | clear: null,
|
2778 |
|
2779 | code: null,
|
2780 |
|
2781 | codeBase: null,
|
2782 |
|
2783 | codeType: null,
|
2784 |
|
2785 | color: null,
|
2786 |
|
2787 | compact: boolean,
|
2788 |
|
2789 | declare: boolean,
|
2790 |
|
2791 | event: null,
|
2792 |
|
2793 | face: null,
|
2794 |
|
2795 | frame: null,
|
2796 |
|
2797 | frameBorder: null,
|
2798 |
|
2799 | hSpace: number,
|
2800 |
|
2801 | leftMargin: number,
|
2802 |
|
2803 | link: null,
|
2804 |
|
2805 | longDesc: null,
|
2806 |
|
2807 | lowSrc: null,
|
2808 |
|
2809 | marginHeight: number,
|
2810 |
|
2811 | marginWidth: number,
|
2812 |
|
2813 | noResize: boolean,
|
2814 |
|
2815 | noHref: boolean,
|
2816 |
|
2817 | noShade: boolean,
|
2818 |
|
2819 | noWrap: boolean,
|
2820 |
|
2821 | object: null,
|
2822 |
|
2823 | profile: null,
|
2824 |
|
2825 | prompt: null,
|
2826 |
|
2827 | rev: null,
|
2828 |
|
2829 | rightMargin: number,
|
2830 |
|
2831 | rules: null,
|
2832 |
|
2833 | scheme: null,
|
2834 |
|
2835 | scrolling: booleanish,
|
2836 |
|
2837 | standby: null,
|
2838 |
|
2839 | summary: null,
|
2840 |
|
2841 | text: null,
|
2842 |
|
2843 | topMargin: number,
|
2844 |
|
2845 | valueType: null,
|
2846 |
|
2847 | version: null,
|
2848 |
|
2849 | vAlign: null,
|
2850 |
|
2851 | vLink: null,
|
2852 |
|
2853 | vSpace: number,
|
2854 |
|
2855 |
|
2856 | allowTransparency: null,
|
2857 | autoCorrect: null,
|
2858 | autoSave: null,
|
2859 | disablePictureInPicture: boolean,
|
2860 | disableRemotePlayback: boolean,
|
2861 | prefix: null,
|
2862 | property: null,
|
2863 | results: number,
|
2864 | security: null,
|
2865 | unselectable: null
|
2866 | }
|
2867 | });
|
2868 | var merge = merge_1;
|
2869 | var xlink = xlink$1;
|
2870 | var xml = xml$1;
|
2871 | var xmlns = xmlns$1;
|
2872 | var aria = aria$1;
|
2873 | var html$1 = html$2;
|
2874 | var html_1$1 = merge([xml, xlink, xmlns, aria, html$1]);
|
2875 | var normalize$1 = normalize_1;
|
2876 | var DefinedInfo = definedInfo;
|
2877 | var Info = info;
|
2878 | var data = 'data';
|
2879 | var find_1 = find$1;
|
2880 | var valid = /^data[-\w.:]+$/i;
|
2881 | var dash$1 = /-[a-z]/g;
|
2882 | var cap$1 = /[A-Z]/g;
|
2883 |
|
2884 | function find$1(schema, value) {
|
2885 | var normal = normalize$1(value);
|
2886 | var prop = value;
|
2887 | var Type = Info;
|
2888 |
|
2889 | if (normal in schema.normal) {
|
2890 | return schema.property[schema.normal[normal]];
|
2891 | }
|
2892 |
|
2893 | if (normal.length > 4 && normal.slice(0, 4) === data && valid.test(value)) {
|
2894 |
|
2895 | if (value.charAt(4) === '-') {
|
2896 | prop = datasetToProperty(value);
|
2897 | } else {
|
2898 | value = datasetToAttribute(value);
|
2899 | }
|
2900 |
|
2901 | Type = DefinedInfo;
|
2902 | }
|
2903 |
|
2904 | return new Type(prop, value);
|
2905 | }
|
2906 |
|
2907 | function datasetToProperty(attribute) {
|
2908 | var value = attribute.slice(5).replace(dash$1, camelcase);
|
2909 | return data + value.charAt(0).toUpperCase() + value.slice(1);
|
2910 | }
|
2911 |
|
2912 | function datasetToAttribute(property) {
|
2913 | var value = property.slice(4);
|
2914 |
|
2915 | if (dash$1.test(value)) {
|
2916 | return property;
|
2917 | }
|
2918 |
|
2919 | value = value.replace(cap$1, kebab);
|
2920 |
|
2921 | if (value.charAt(0) !== '-') {
|
2922 | value = '-' + value;
|
2923 | }
|
2924 |
|
2925 | return data + value;
|
2926 | }
|
2927 |
|
2928 | function kebab($0) {
|
2929 | return '-' + $0.toLowerCase();
|
2930 | }
|
2931 |
|
2932 | function camelcase($0) {
|
2933 | return $0.charAt(1).toUpperCase();
|
2934 | }
|
2935 |
|
2936 | var hastUtilParseSelector = parse$3;
|
2937 | var search = /[#.]/g;
|
2938 |
|
2939 | function parse$3(selector, defaultTagName) {
|
2940 | var value = selector || '';
|
2941 | var name = defaultTagName || 'div';
|
2942 | var props = {};
|
2943 | var start = 0;
|
2944 | var subvalue;
|
2945 | var previous;
|
2946 | var match;
|
2947 |
|
2948 | while (start < value.length) {
|
2949 | search.lastIndex = start;
|
2950 | match = search.exec(value);
|
2951 | subvalue = value.slice(start, match ? match.index : value.length);
|
2952 |
|
2953 | if (subvalue) {
|
2954 | if (!previous) {
|
2955 | name = subvalue;
|
2956 | } else if (previous === '#') {
|
2957 | props.id = subvalue;
|
2958 | } else if (props.className) {
|
2959 | props.className.push(subvalue);
|
2960 | } else {
|
2961 | props.className = [subvalue];
|
2962 | }
|
2963 |
|
2964 | start += subvalue.length;
|
2965 | }
|
2966 |
|
2967 | if (match) {
|
2968 | previous = match[0];
|
2969 | start++;
|
2970 | }
|
2971 | }
|
2972 |
|
2973 | return {
|
2974 | type: 'element',
|
2975 | tagName: name,
|
2976 | properties: props,
|
2977 | children: []
|
2978 | };
|
2979 | }
|
2980 |
|
2981 | var spaceSeparatedTokens = {};
|
2982 | spaceSeparatedTokens.parse = parse$2;
|
2983 | spaceSeparatedTokens.stringify = stringify$2;
|
2984 | var empty$2 = '';
|
2985 | var space$2 = ' ';
|
2986 | var whiteSpace = /[ \t\n\r\f]+/g;
|
2987 |
|
2988 | function parse$2(value) {
|
2989 | var input = String(value || empty$2).trim();
|
2990 | return input === empty$2 ? [] : input.split(whiteSpace);
|
2991 | }
|
2992 |
|
2993 | function stringify$2(values) {
|
2994 | return values.join(space$2).trim();
|
2995 | }
|
2996 |
|
2997 | var commaSeparatedTokens = {};
|
2998 | commaSeparatedTokens.parse = parse$1;
|
2999 | commaSeparatedTokens.stringify = stringify$1;
|
3000 | var comma$1 = ',';
|
3001 | var space$1 = ' ';
|
3002 | var empty$1 = '';
|
3003 |
|
3004 | function parse$1(value) {
|
3005 | var values = [];
|
3006 | var input = String(value || empty$1);
|
3007 | var index = input.indexOf(comma$1);
|
3008 | var lastIndex = 0;
|
3009 | var end = false;
|
3010 | var val;
|
3011 |
|
3012 | while (!end) {
|
3013 | if (index === -1) {
|
3014 | index = input.length;
|
3015 | end = true;
|
3016 | }
|
3017 |
|
3018 | val = input.slice(lastIndex, index).trim();
|
3019 |
|
3020 | if (val || !end) {
|
3021 | values.push(val);
|
3022 | }
|
3023 |
|
3024 | lastIndex = index + 1;
|
3025 | index = input.indexOf(comma$1, lastIndex);
|
3026 | }
|
3027 |
|
3028 | return values;
|
3029 | }
|
3030 |
|
3031 |
|
3032 |
|
3033 |
|
3034 | function stringify$1(values, options) {
|
3035 | var settings = options || {};
|
3036 | var left = settings.padLeft === false ? empty$1 : space$1;
|
3037 | var right = settings.padRight ? space$1 : empty$1;
|
3038 |
|
3039 | if (values[values.length - 1] === empty$1) {
|
3040 | values = values.concat(empty$1);
|
3041 | }
|
3042 |
|
3043 | return values.join(right + comma$1 + left).trim();
|
3044 | }
|
3045 |
|
3046 | var find = find_1;
|
3047 | var normalize = normalize_1;
|
3048 | var parseSelector = hastUtilParseSelector;
|
3049 | var spaces = spaceSeparatedTokens.parse;
|
3050 | var commas = commaSeparatedTokens.parse;
|
3051 | var factory_1 = factory$1;
|
3052 | var own$3 = {}.hasOwnProperty;
|
3053 |
|
3054 | function factory$1(schema, defaultTagName, caseSensitive) {
|
3055 | var adjust = caseSensitive ? createAdjustMap(caseSensitive) : null;
|
3056 | return h;
|
3057 |
|
3058 | function h(selector, properties) {
|
3059 | var node = parseSelector(selector, defaultTagName);
|
3060 | var children = Array.prototype.slice.call(arguments, 2);
|
3061 | var name = node.tagName.toLowerCase();
|
3062 | var property;
|
3063 | node.tagName = adjust && own$3.call(adjust, name) ? adjust[name] : name;
|
3064 |
|
3065 | if (properties && isChildren(properties, node)) {
|
3066 | children.unshift(properties);
|
3067 | properties = null;
|
3068 | }
|
3069 |
|
3070 | if (properties) {
|
3071 | for (property in properties) {
|
3072 | addProperty(node.properties, property, properties[property]);
|
3073 | }
|
3074 | }
|
3075 |
|
3076 | addChild(node.children, children);
|
3077 |
|
3078 | if (node.tagName === 'template') {
|
3079 | node.content = {
|
3080 | type: 'root',
|
3081 | children: node.children
|
3082 | };
|
3083 | node.children = [];
|
3084 | }
|
3085 |
|
3086 | return node;
|
3087 | }
|
3088 |
|
3089 | function addProperty(properties, key, value) {
|
3090 | var info;
|
3091 | var property;
|
3092 | var result;
|
3093 |
|
3094 | if (value === null || value === undefined || value !== value) {
|
3095 | return;
|
3096 | }
|
3097 |
|
3098 | info = find(schema, key);
|
3099 | property = info.property;
|
3100 | result = value;
|
3101 |
|
3102 | if (typeof result === 'string') {
|
3103 | if (info.spaceSeparated) {
|
3104 | result = spaces(result);
|
3105 | } else if (info.commaSeparated) {
|
3106 | result = commas(result);
|
3107 | } else if (info.commaOrSpaceSeparated) {
|
3108 | result = spaces(commas(result).join(' '));
|
3109 | }
|
3110 | }
|
3111 |
|
3112 |
|
3113 | if (property === 'style' && typeof value !== 'string') {
|
3114 | result = style(result);
|
3115 | }
|
3116 |
|
3117 |
|
3118 | if (property === 'className' && properties.className) {
|
3119 | result = properties.className.concat(result);
|
3120 | }
|
3121 |
|
3122 | properties[property] = parsePrimitives(info, property, result);
|
3123 | }
|
3124 | }
|
3125 |
|
3126 | function isChildren(value, node) {
|
3127 | return typeof value === 'string' || 'length' in value || isNode(node.tagName, value);
|
3128 | }
|
3129 |
|
3130 | function isNode(tagName, value) {
|
3131 | var type = value.type;
|
3132 |
|
3133 | if (tagName === 'input' || !type || typeof type !== 'string') {
|
3134 | return false;
|
3135 | }
|
3136 |
|
3137 | if (_typeof(value.children) === 'object' && 'length' in value.children) {
|
3138 | return true;
|
3139 | }
|
3140 |
|
3141 | type = type.toLowerCase();
|
3142 |
|
3143 | if (tagName === 'button') {
|
3144 | return type !== 'menu' && type !== 'submit' && type !== 'reset' && type !== 'button';
|
3145 | }
|
3146 |
|
3147 | return 'value' in value;
|
3148 | }
|
3149 |
|
3150 | function addChild(nodes, value) {
|
3151 | var index;
|
3152 | var length;
|
3153 |
|
3154 | if (typeof value === 'string' || typeof value === 'number') {
|
3155 | nodes.push({
|
3156 | type: 'text',
|
3157 | value: String(value)
|
3158 | });
|
3159 | return;
|
3160 | }
|
3161 |
|
3162 | if (_typeof(value) === 'object' && 'length' in value) {
|
3163 | index = -1;
|
3164 | length = value.length;
|
3165 |
|
3166 | while (++index < length) {
|
3167 | addChild(nodes, value[index]);
|
3168 | }
|
3169 |
|
3170 | return;
|
3171 | }
|
3172 |
|
3173 | if (_typeof(value) !== 'object' || !('type' in value)) {
|
3174 | throw new Error('Expected node, nodes, or string, got `' + value + '`');
|
3175 | }
|
3176 |
|
3177 | nodes.push(value);
|
3178 | }
|
3179 |
|
3180 |
|
3181 | function parsePrimitives(info, name, value) {
|
3182 | var index;
|
3183 | var length;
|
3184 | var result;
|
3185 |
|
3186 | if (_typeof(value) !== 'object' || !('length' in value)) {
|
3187 | return parsePrimitive(info, name, value);
|
3188 | }
|
3189 |
|
3190 | length = value.length;
|
3191 | index = -1;
|
3192 | result = [];
|
3193 |
|
3194 | while (++index < length) {
|
3195 | result[index] = parsePrimitive(info, name, value[index]);
|
3196 | }
|
3197 |
|
3198 | return result;
|
3199 | }
|
3200 |
|
3201 |
|
3202 | function parsePrimitive(info, name, value) {
|
3203 | var result = value;
|
3204 |
|
3205 | if (info.number || info.positiveNumber) {
|
3206 | if (!isNaN(result) && result !== '') {
|
3207 | result = Number(result);
|
3208 | }
|
3209 | } else if (info.boolean || info.overloadedBoolean) {
|
3210 |
|
3211 | if (typeof result === 'string' && (result === '' || normalize(value) === normalize(name))) {
|
3212 | result = true;
|
3213 | }
|
3214 | }
|
3215 |
|
3216 | return result;
|
3217 | }
|
3218 |
|
3219 | function style(value) {
|
3220 | var result = [];
|
3221 | var key;
|
3222 |
|
3223 | for (key in value) {
|
3224 | result.push([key, value[key]].join(': '));
|
3225 | }
|
3226 |
|
3227 | return result.join('; ');
|
3228 | }
|
3229 |
|
3230 | function createAdjustMap(values) {
|
3231 | var length = values.length;
|
3232 | var index = -1;
|
3233 | var result = {};
|
3234 | var value;
|
3235 |
|
3236 | while (++index < length) {
|
3237 | value = values[index];
|
3238 | result[value.toLowerCase()] = value;
|
3239 | }
|
3240 |
|
3241 | return result;
|
3242 | }
|
3243 |
|
3244 | var schema = html_1$1;
|
3245 | var factory = factory_1;
|
3246 | var html = factory(schema, 'div');
|
3247 | html.displayName = 'html';
|
3248 | var html_1 = html;
|
3249 | var hastscript = html_1;
|
3250 | var AElig$1 = "Æ";
|
3251 | var AMP$1 = "&";
|
3252 | var Aacute$1 = "Á";
|
3253 | var Acirc$1 = "Â";
|
3254 | var Agrave$1 = "À";
|
3255 | var Aring$1 = "Å";
|
3256 | var Atilde$1 = "Ã";
|
3257 | var Auml$1 = "Ä";
|
3258 | var COPY$1 = "©";
|
3259 | var Ccedil$1 = "Ç";
|
3260 | var ETH$1 = "Ð";
|
3261 | var Eacute$1 = "É";
|
3262 | var Ecirc$1 = "Ê";
|
3263 | var Egrave$1 = "È";
|
3264 | var Euml$1 = "Ë";
|
3265 | var GT$1 = ">";
|
3266 | var Iacute$1 = "Í";
|
3267 | var Icirc$1 = "Î";
|
3268 | var Igrave$1 = "Ì";
|
3269 | var Iuml$1 = "Ï";
|
3270 | var LT$1 = "<";
|
3271 | var Ntilde$1 = "Ñ";
|
3272 | var Oacute$1 = "Ó";
|
3273 | var Ocirc$1 = "Ô";
|
3274 | var Ograve$1 = "Ò";
|
3275 | var Oslash$1 = "Ø";
|
3276 | var Otilde$1 = "Õ";
|
3277 | var Ouml$1 = "Ö";
|
3278 | var QUOT$1 = "\"";
|
3279 | var REG$1 = "®";
|
3280 | var THORN$1 = "Þ";
|
3281 | var Uacute$1 = "Ú";
|
3282 | var Ucirc$1 = "Û";
|
3283 | var Ugrave$1 = "Ù";
|
3284 | var Uuml$1 = "Ü";
|
3285 | var Yacute$1 = "Ý";
|
3286 | var aacute$1 = "á";
|
3287 | var acirc$1 = "â";
|
3288 | var acute$1 = "´";
|
3289 | var aelig$1 = "æ";
|
3290 | var agrave$1 = "à";
|
3291 | var amp$1 = "&";
|
3292 | var aring$1 = "å";
|
3293 | var atilde$1 = "ã";
|
3294 | var auml$1 = "ä";
|
3295 | var brvbar$1 = "¦";
|
3296 | var ccedil$1 = "ç";
|
3297 | var cedil$1 = "¸";
|
3298 | var cent$1 = "¢";
|
3299 | var copy$1 = "©";
|
3300 | var curren$1 = "¤";
|
3301 | var deg$1 = "°";
|
3302 | var divide$1 = "÷";
|
3303 | var eacute$1 = "é";
|
3304 | var ecirc$1 = "ê";
|
3305 | var egrave$1 = "è";
|
3306 | var eth$1 = "ð";
|
3307 | var euml$1 = "ë";
|
3308 | var frac12$1 = "½";
|
3309 | var frac14$1 = "¼";
|
3310 | var frac34$1 = "¾";
|
3311 | var gt$1 = ">";
|
3312 | var iacute$1 = "í";
|
3313 | var icirc$1 = "î";
|
3314 | var iexcl$1 = "¡";
|
3315 | var igrave$1 = "ì";
|
3316 | var iquest$1 = "¿";
|
3317 | var iuml$1 = "ï";
|
3318 | var laquo$1 = "«";
|
3319 | var lt$1 = "<";
|
3320 | var macr$1 = "¯";
|
3321 | var micro$1 = "µ";
|
3322 | var middot$1 = "·";
|
3323 | var nbsp$1 = " ";
|
3324 | var not$1 = "¬";
|
3325 | var ntilde$1 = "ñ";
|
3326 | var oacute$1 = "ó";
|
3327 | var ocirc$1 = "ô";
|
3328 | var ograve$1 = "ò";
|
3329 | var ordf$1 = "ª";
|
3330 | var ordm$1 = "º";
|
3331 | var oslash$1 = "ø";
|
3332 | var otilde$1 = "õ";
|
3333 | var ouml$1 = "ö";
|
3334 | var para$1 = "¶";
|
3335 | var plusmn$1 = "±";
|
3336 | var pound$1 = "£";
|
3337 | var quot$1 = "\"";
|
3338 | var raquo$1 = "»";
|
3339 | var reg$1 = "®";
|
3340 | var sect$1 = "§";
|
3341 | var shy$1 = "";
|
3342 | var sup1$1 = "¹";
|
3343 | var sup2$1 = "²";
|
3344 | var sup3$1 = "³";
|
3345 | var szlig$1 = "ß";
|
3346 | var thorn$1 = "þ";
|
3347 | var times$1 = "×";
|
3348 | var uacute$1 = "ú";
|
3349 | var ucirc$1 = "û";
|
3350 | var ugrave$1 = "ù";
|
3351 | var uml$1 = "¨";
|
3352 | var uuml$1 = "ü";
|
3353 | var yacute$1 = "ý";
|
3354 | var yen$1 = "¥";
|
3355 | var yuml$1 = "ÿ";
|
3356 | var require$$0$1 = {
|
3357 | AElig: AElig$1,
|
3358 | AMP: AMP$1,
|
3359 | Aacute: Aacute$1,
|
3360 | Acirc: Acirc$1,
|
3361 | Agrave: Agrave$1,
|
3362 | Aring: Aring$1,
|
3363 | Atilde: Atilde$1,
|
3364 | Auml: Auml$1,
|
3365 | COPY: COPY$1,
|
3366 | Ccedil: Ccedil$1,
|
3367 | ETH: ETH$1,
|
3368 | Eacute: Eacute$1,
|
3369 | Ecirc: Ecirc$1,
|
3370 | Egrave: Egrave$1,
|
3371 | Euml: Euml$1,
|
3372 | GT: GT$1,
|
3373 | Iacute: Iacute$1,
|
3374 | Icirc: Icirc$1,
|
3375 | Igrave: Igrave$1,
|
3376 | Iuml: Iuml$1,
|
3377 | LT: LT$1,
|
3378 | Ntilde: Ntilde$1,
|
3379 | Oacute: Oacute$1,
|
3380 | Ocirc: Ocirc$1,
|
3381 | Ograve: Ograve$1,
|
3382 | Oslash: Oslash$1,
|
3383 | Otilde: Otilde$1,
|
3384 | Ouml: Ouml$1,
|
3385 | QUOT: QUOT$1,
|
3386 | REG: REG$1,
|
3387 | THORN: THORN$1,
|
3388 | Uacute: Uacute$1,
|
3389 | Ucirc: Ucirc$1,
|
3390 | Ugrave: Ugrave$1,
|
3391 | Uuml: Uuml$1,
|
3392 | Yacute: Yacute$1,
|
3393 | aacute: aacute$1,
|
3394 | acirc: acirc$1,
|
3395 | acute: acute$1,
|
3396 | aelig: aelig$1,
|
3397 | agrave: agrave$1,
|
3398 | amp: amp$1,
|
3399 | aring: aring$1,
|
3400 | atilde: atilde$1,
|
3401 | auml: auml$1,
|
3402 | brvbar: brvbar$1,
|
3403 | ccedil: ccedil$1,
|
3404 | cedil: cedil$1,
|
3405 | cent: cent$1,
|
3406 | copy: copy$1,
|
3407 | curren: curren$1,
|
3408 | deg: deg$1,
|
3409 | divide: divide$1,
|
3410 | eacute: eacute$1,
|
3411 | ecirc: ecirc$1,
|
3412 | egrave: egrave$1,
|
3413 | eth: eth$1,
|
3414 | euml: euml$1,
|
3415 | frac12: frac12$1,
|
3416 | frac14: frac14$1,
|
3417 | frac34: frac34$1,
|
3418 | gt: gt$1,
|
3419 | iacute: iacute$1,
|
3420 | icirc: icirc$1,
|
3421 | iexcl: iexcl$1,
|
3422 | igrave: igrave$1,
|
3423 | iquest: iquest$1,
|
3424 | iuml: iuml$1,
|
3425 | laquo: laquo$1,
|
3426 | lt: lt$1,
|
3427 | macr: macr$1,
|
3428 | micro: micro$1,
|
3429 | middot: middot$1,
|
3430 | nbsp: nbsp$1,
|
3431 | not: not$1,
|
3432 | ntilde: ntilde$1,
|
3433 | oacute: oacute$1,
|
3434 | ocirc: ocirc$1,
|
3435 | ograve: ograve$1,
|
3436 | ordf: ordf$1,
|
3437 | ordm: ordm$1,
|
3438 | oslash: oslash$1,
|
3439 | otilde: otilde$1,
|
3440 | ouml: ouml$1,
|
3441 | para: para$1,
|
3442 | plusmn: plusmn$1,
|
3443 | pound: pound$1,
|
3444 | quot: quot$1,
|
3445 | raquo: raquo$1,
|
3446 | reg: reg$1,
|
3447 | sect: sect$1,
|
3448 | shy: shy$1,
|
3449 | sup1: sup1$1,
|
3450 | sup2: sup2$1,
|
3451 | sup3: sup3$1,
|
3452 | szlig: szlig$1,
|
3453 | thorn: thorn$1,
|
3454 | times: times$1,
|
3455 | uacute: uacute$1,
|
3456 | ucirc: ucirc$1,
|
3457 | ugrave: ugrave$1,
|
3458 | uml: uml$1,
|
3459 | uuml: uuml$1,
|
3460 | yacute: yacute$1,
|
3461 | yen: yen$1,
|
3462 | yuml: yuml$1
|
3463 | };
|
3464 | var require$$1 = {
|
3465 | "0": "�",
|
3466 | "128": "€",
|
3467 | "130": "‚",
|
3468 | "131": "ƒ",
|
3469 | "132": "„",
|
3470 | "133": "…",
|
3471 | "134": "†",
|
3472 | "135": "‡",
|
3473 | "136": "ˆ",
|
3474 | "137": "‰",
|
3475 | "138": "Š",
|
3476 | "139": "‹",
|
3477 | "140": "Œ",
|
3478 | "142": "Ž",
|
3479 | "145": "‘",
|
3480 | "146": "’",
|
3481 | "147": "“",
|
3482 | "148": "”",
|
3483 | "149": "•",
|
3484 | "150": "–",
|
3485 | "151": "—",
|
3486 | "152": "˜",
|
3487 | "153": "™",
|
3488 | "154": "š",
|
3489 | "155": "›",
|
3490 | "156": "œ",
|
3491 | "158": "ž",
|
3492 | "159": "Ÿ"
|
3493 | };
|
3494 | var isDecimal = decimal$2;
|
3495 |
|
3496 |
|
3497 | function decimal$2(character) {
|
3498 | var code = typeof character === 'string' ? character.charCodeAt(0) : character;
|
3499 | return code >= 48 && code <= 57;
|
3500 |
|
3501 | }
|
3502 |
|
3503 | var isHexadecimal = hexadecimal$1;
|
3504 |
|
3505 |
|
3506 | function hexadecimal$1(character) {
|
3507 | var code = typeof character === 'string' ? character.charCodeAt(0) : character;
|
3508 | return code >= 97
|
3509 |
|
3510 | && code <= 102
|
3511 |
|
3512 | || code >= 65
|
3513 |
|
3514 | && code <= 70
|
3515 |
|
3516 | || code >= 48
|
3517 |
|
3518 | && code <= 57
|
3519 |
|
3520 | ;
|
3521 | }
|
3522 |
|
3523 | var isAlphabetical = alphabetical$1;
|
3524 |
|
3525 |
|
3526 | function alphabetical$1(character) {
|
3527 | var code = typeof character === 'string' ? character.charCodeAt(0) : character;
|
3528 | return code >= 97 && code <= 122
|
3529 |
|
3530 | || code >= 65 && code <= 90
|
3531 |
|
3532 | ;
|
3533 | }
|
3534 |
|
3535 | var alphabetical = isAlphabetical;
|
3536 | var decimal$1 = isDecimal;
|
3537 | var isAlphanumerical = alphanumerical$1;
|
3538 |
|
3539 |
|
3540 | function alphanumerical$1(character) {
|
3541 | return alphabetical(character) || decimal$1(character);
|
3542 | }
|
3543 |
|
3544 | var AEli = "Æ";
|
3545 | var AElig = "Æ";
|
3546 | var AM = "&";
|
3547 | var AMP = "&";
|
3548 | var Aacut = "Á";
|
3549 | var Aacute = "Á";
|
3550 | var Abreve = "Ă";
|
3551 | var Acir = "Â";
|
3552 | var Acirc = "Â";
|
3553 | var Acy = "А";
|
3554 | var Afr = "𝔄";
|
3555 | var Agrav = "À";
|
3556 | var Agrave = "À";
|
3557 | var Alpha = "Α";
|
3558 | var Amacr = "Ā";
|
3559 | var And = "⩓";
|
3560 | var Aogon = "Ą";
|
3561 | var Aopf = "𝔸";
|
3562 | var ApplyFunction = "";
|
3563 | var Arin = "Å";
|
3564 | var Aring = "Å";
|
3565 | var Ascr = "𝒜";
|
3566 | var Assign = "≔";
|
3567 | var Atild = "Ã";
|
3568 | var Atilde = "Ã";
|
3569 | var Aum = "Ä";
|
3570 | var Auml = "Ä";
|
3571 | var Backslash = "∖";
|
3572 | var Barv = "⫧";
|
3573 | var Barwed = "⌆";
|
3574 | var Bcy = "Б";
|
3575 | var Because = "∵";
|
3576 | var Bernoullis = "ℬ";
|
3577 | var Beta = "Β";
|
3578 | var Bfr = "𝔅";
|
3579 | var Bopf = "𝔹";
|
3580 | var Breve = "˘";
|
3581 | var Bscr = "ℬ";
|
3582 | var Bumpeq = "≎";
|
3583 | var CHcy = "Ч";
|
3584 | var COP = "©";
|
3585 | var COPY = "©";
|
3586 | var Cacute = "Ć";
|
3587 | var Cap = "⋒";
|
3588 | var CapitalDifferentialD = "ⅅ";
|
3589 | var Cayleys = "ℭ";
|
3590 | var Ccaron = "Č";
|
3591 | var Ccedi = "Ç";
|
3592 | var Ccedil = "Ç";
|
3593 | var Ccirc = "Ĉ";
|
3594 | var Cconint = "∰";
|
3595 | var Cdot = "Ċ";
|
3596 | var Cedilla = "¸";
|
3597 | var CenterDot = "·";
|
3598 | var Cfr = "ℭ";
|
3599 | var Chi = "Χ";
|
3600 | var CircleDot = "⊙";
|
3601 | var CircleMinus = "⊖";
|
3602 | var CirclePlus = "⊕";
|
3603 | var CircleTimes = "⊗";
|
3604 | var ClockwiseContourIntegral = "∲";
|
3605 | var CloseCurlyDoubleQuote = "”";
|
3606 | var CloseCurlyQuote = "’";
|
3607 | var Colon = "∷";
|
3608 | var Colone = "⩴";
|
3609 | var Congruent = "≡";
|
3610 | var Conint = "∯";
|
3611 | var ContourIntegral = "∮";
|
3612 | var Copf = "ℂ";
|
3613 | var Coproduct = "∐";
|
3614 | var CounterClockwiseContourIntegral = "∳";
|
3615 | var Cross = "⨯";
|
3616 | var Cscr = "𝒞";
|
3617 | var Cup = "⋓";
|
3618 | var CupCap = "≍";
|
3619 | var DD = "ⅅ";
|
3620 | var DDotrahd = "⤑";
|
3621 | var DJcy = "Ђ";
|
3622 | var DScy = "Ѕ";
|
3623 | var DZcy = "Џ";
|
3624 | var Dagger = "‡";
|
3625 | var Darr = "↡";
|
3626 | var Dashv = "⫤";
|
3627 | var Dcaron = "Ď";
|
3628 | var Dcy = "Д";
|
3629 | var Del = "∇";
|
3630 | var Delta = "Δ";
|
3631 | var Dfr = "𝔇";
|
3632 | var DiacriticalAcute = "´";
|
3633 | var DiacriticalDot = "˙";
|
3634 | var DiacriticalDoubleAcute = "˝";
|
3635 | var DiacriticalGrave = "`";
|
3636 | var DiacriticalTilde = "˜";
|
3637 | var Diamond = "⋄";
|
3638 | var DifferentialD = "ⅆ";
|
3639 | var Dopf = "𝔻";
|
3640 | var Dot = "¨";
|
3641 | var DotDot = "⃜";
|
3642 | var DotEqual = "≐";
|
3643 | var DoubleContourIntegral = "∯";
|
3644 | var DoubleDot = "¨";
|
3645 | var DoubleDownArrow = "⇓";
|
3646 | var DoubleLeftArrow = "⇐";
|
3647 | var DoubleLeftRightArrow = "⇔";
|
3648 | var DoubleLeftTee = "⫤";
|
3649 | var DoubleLongLeftArrow = "⟸";
|
3650 | var DoubleLongLeftRightArrow = "⟺";
|
3651 | var DoubleLongRightArrow = "⟹";
|
3652 | var DoubleRightArrow = "⇒";
|
3653 | var DoubleRightTee = "⊨";
|
3654 | var DoubleUpArrow = "⇑";
|
3655 | var DoubleUpDownArrow = "⇕";
|
3656 | var DoubleVerticalBar = "∥";
|
3657 | var DownArrow = "↓";
|
3658 | var DownArrowBar = "⤓";
|
3659 | var DownArrowUpArrow = "⇵";
|
3660 | var DownBreve = "̑";
|
3661 | var DownLeftRightVector = "⥐";
|
3662 | var DownLeftTeeVector = "⥞";
|
3663 | var DownLeftVector = "↽";
|
3664 | var DownLeftVectorBar = "⥖";
|
3665 | var DownRightTeeVector = "⥟";
|
3666 | var DownRightVector = "⇁";
|
3667 | var DownRightVectorBar = "⥗";
|
3668 | var DownTee = "⊤";
|
3669 | var DownTeeArrow = "↧";
|
3670 | var Downarrow = "⇓";
|
3671 | var Dscr = "𝒟";
|
3672 | var Dstrok = "Đ";
|
3673 | var ENG = "Ŋ";
|
3674 | var ET = "Ð";
|
3675 | var ETH = "Ð";
|
3676 | var Eacut = "É";
|
3677 | var Eacute = "É";
|
3678 | var Ecaron = "Ě";
|
3679 | var Ecir = "Ê";
|
3680 | var Ecirc = "Ê";
|
3681 | var Ecy = "Э";
|
3682 | var Edot = "Ė";
|
3683 | var Efr = "𝔈";
|
3684 | var Egrav = "È";
|
3685 | var Egrave = "È";
|
3686 | var Element = "∈";
|
3687 | var Emacr = "Ē";
|
3688 | var EmptySmallSquare = "◻";
|
3689 | var EmptyVerySmallSquare = "▫";
|
3690 | var Eogon = "Ę";
|
3691 | var Eopf = "𝔼";
|
3692 | var Epsilon = "Ε";
|
3693 | var Equal = "⩵";
|
3694 | var EqualTilde = "≂";
|
3695 | var Equilibrium = "⇌";
|
3696 | var Escr = "ℰ";
|
3697 | var Esim = "⩳";
|
3698 | var Eta = "Η";
|
3699 | var Eum = "Ë";
|
3700 | var Euml = "Ë";
|
3701 | var Exists = "∃";
|
3702 | var ExponentialE = "ⅇ";
|
3703 | var Fcy = "Ф";
|
3704 | var Ffr = "𝔉";
|
3705 | var FilledSmallSquare = "◼";
|
3706 | var FilledVerySmallSquare = "▪";
|
3707 | var Fopf = "𝔽";
|
3708 | var ForAll = "∀";
|
3709 | var Fouriertrf = "ℱ";
|
3710 | var Fscr = "ℱ";
|
3711 | var GJcy = "Ѓ";
|
3712 | var G = ">";
|
3713 | var GT = ">";
|
3714 | var Gamma = "Γ";
|
3715 | var Gammad = "Ϝ";
|
3716 | var Gbreve = "Ğ";
|
3717 | var Gcedil = "Ģ";
|
3718 | var Gcirc = "Ĝ";
|
3719 | var Gcy = "Г";
|
3720 | var Gdot = "Ġ";
|
3721 | var Gfr = "𝔊";
|
3722 | var Gg = "⋙";
|
3723 | var Gopf = "𝔾";
|
3724 | var GreaterEqual = "≥";
|
3725 | var GreaterEqualLess = "⋛";
|
3726 | var GreaterFullEqual = "≧";
|
3727 | var GreaterGreater = "⪢";
|
3728 | var GreaterLess = "≷";
|
3729 | var GreaterSlantEqual = "⩾";
|
3730 | var GreaterTilde = "≳";
|
3731 | var Gscr = "𝒢";
|
3732 | var Gt = "≫";
|
3733 | var HARDcy = "Ъ";
|
3734 | var Hacek = "ˇ";
|
3735 | var Hat = "^";
|
3736 | var Hcirc = "Ĥ";
|
3737 | var Hfr = "ℌ";
|
3738 | var HilbertSpace = "ℋ";
|
3739 | var Hopf = "ℍ";
|
3740 | var HorizontalLine = "─";
|
3741 | var Hscr = "ℋ";
|
3742 | var Hstrok = "Ħ";
|
3743 | var HumpDownHump = "≎";
|
3744 | var HumpEqual = "≏";
|
3745 | var IEcy = "Е";
|
3746 | var IJlig = "IJ";
|
3747 | var IOcy = "Ё";
|
3748 | var Iacut = "Í";
|
3749 | var Iacute = "Í";
|
3750 | var Icir = "Î";
|
3751 | var Icirc = "Î";
|
3752 | var Icy = "И";
|
3753 | var Idot = "İ";
|
3754 | var Ifr = "ℑ";
|
3755 | var Igrav = "Ì";
|
3756 | var Igrave = "Ì";
|
3757 | var Im = "ℑ";
|
3758 | var Imacr = "Ī";
|
3759 | var ImaginaryI = "ⅈ";
|
3760 | var Implies = "⇒";
|
3761 | var Int = "∬";
|
3762 | var Integral = "∫";
|
3763 | var Intersection = "⋂";
|
3764 | var InvisibleComma = "";
|
3765 | var InvisibleTimes = "";
|
3766 | var Iogon = "Į";
|
3767 | var Iopf = "𝕀";
|
3768 | var Iota = "Ι";
|
3769 | var Iscr = "ℐ";
|
3770 | var Itilde = "Ĩ";
|
3771 | var Iukcy = "І";
|
3772 | var Ium = "Ï";
|
3773 | var Iuml = "Ï";
|
3774 | var Jcirc = "Ĵ";
|
3775 | var Jcy = "Й";
|
3776 | var Jfr = "𝔍";
|
3777 | var Jopf = "𝕁";
|
3778 | var Jscr = "𝒥";
|
3779 | var Jsercy = "Ј";
|
3780 | var Jukcy = "Є";
|
3781 | var KHcy = "Х";
|
3782 | var KJcy = "Ќ";
|
3783 | var Kappa = "Κ";
|
3784 | var Kcedil = "Ķ";
|
3785 | var Kcy = "К";
|
3786 | var Kfr = "𝔎";
|
3787 | var Kopf = "𝕂";
|
3788 | var Kscr = "𝒦";
|
3789 | var LJcy = "Љ";
|
3790 | var L = "<";
|
3791 | var LT = "<";
|
3792 | var Lacute = "Ĺ";
|
3793 | var Lambda = "Λ";
|
3794 | var Lang = "⟪";
|
3795 | var Laplacetrf = "ℒ";
|
3796 | var Larr = "↞";
|
3797 | var Lcaron = "Ľ";
|
3798 | var Lcedil = "Ļ";
|
3799 | var Lcy = "Л";
|
3800 | var LeftAngleBracket = "⟨";
|
3801 | var LeftArrow = "←";
|
3802 | var LeftArrowBar = "⇤";
|
3803 | var LeftArrowRightArrow = "⇆";
|
3804 | var LeftCeiling = "⌈";
|
3805 | var LeftDoubleBracket = "⟦";
|
3806 | var LeftDownTeeVector = "⥡";
|
3807 | var LeftDownVector = "⇃";
|
3808 | var LeftDownVectorBar = "⥙";
|
3809 | var LeftFloor = "⌊";
|
3810 | var LeftRightArrow = "↔";
|
3811 | var LeftRightVector = "⥎";
|
3812 | var LeftTee = "⊣";
|
3813 | var LeftTeeArrow = "↤";
|
3814 | var LeftTeeVector = "⥚";
|
3815 | var LeftTriangle = "⊲";
|
3816 | var LeftTriangleBar = "⧏";
|
3817 | var LeftTriangleEqual = "⊴";
|
3818 | var LeftUpDownVector = "⥑";
|
3819 | var LeftUpTeeVector = "⥠";
|
3820 | var LeftUpVector = "↿";
|
3821 | var LeftUpVectorBar = "⥘";
|
3822 | var LeftVector = "↼";
|
3823 | var LeftVectorBar = "⥒";
|
3824 | var Leftarrow = "⇐";
|
3825 | var Leftrightarrow = "⇔";
|
3826 | var LessEqualGreater = "⋚";
|
3827 | var LessFullEqual = "≦";
|
3828 | var LessGreater = "≶";
|
3829 | var LessLess = "⪡";
|
3830 | var LessSlantEqual = "⩽";
|
3831 | var LessTilde = "≲";
|
3832 | var Lfr = "𝔏";
|
3833 | var Ll = "⋘";
|
3834 | var Lleftarrow = "⇚";
|
3835 | var Lmidot = "Ŀ";
|
3836 | var LongLeftArrow = "⟵";
|
3837 | var LongLeftRightArrow = "⟷";
|
3838 | var LongRightArrow = "⟶";
|
3839 | var Longleftarrow = "⟸";
|
3840 | var Longleftrightarrow = "⟺";
|
3841 | var Longrightarrow = "⟹";
|
3842 | var Lopf = "𝕃";
|
3843 | var LowerLeftArrow = "↙";
|
3844 | var LowerRightArrow = "↘";
|
3845 | var Lscr = "ℒ";
|
3846 | var Lsh = "↰";
|
3847 | var Lstrok = "Ł";
|
3848 | var Lt = "≪";
|
3849 | var Mcy = "М";
|
3850 | var MediumSpace = " ";
|
3851 | var Mellintrf = "ℳ";
|
3852 | var Mfr = "𝔐";
|
3853 | var MinusPlus = "∓";
|
3854 | var Mopf = "𝕄";
|
3855 | var Mscr = "ℳ";
|
3856 | var Mu = "Μ";
|
3857 | var NJcy = "Њ";
|
3858 | var Nacute = "Ń";
|
3859 | var Ncaron = "Ň";
|
3860 | var Ncedil = "Ņ";
|
3861 | var Ncy = "Н";
|
3862 | var NegativeMediumSpace = "";
|
3863 | var NegativeThickSpace = "";
|
3864 | var NegativeThinSpace = "";
|
3865 | var NegativeVeryThinSpace = "";
|
3866 | var NestedGreaterGreater = "≫";
|
3867 | var NestedLessLess = "≪";
|
3868 | var NewLine = "\n";
|
3869 | var Nfr = "𝔑";
|
3870 | var NoBreak = "";
|
3871 | var NonBreakingSpace = " ";
|
3872 | var Nopf = "ℕ";
|
3873 | var Not = "⫬";
|
3874 | var NotCongruent = "≢";
|
3875 | var NotCupCap = "≭";
|
3876 | var NotDoubleVerticalBar = "∦";
|
3877 | var NotElement = "∉";
|
3878 | var NotEqual = "≠";
|
3879 | var NotEqualTilde = "≂̸";
|
3880 | var NotExists = "∄";
|
3881 | var NotGreater = "≯";
|
3882 | var NotGreaterEqual = "≱";
|
3883 | var NotGreaterFullEqual = "≧̸";
|
3884 | var NotGreaterGreater = "≫̸";
|
3885 | var NotGreaterLess = "≹";
|
3886 | var NotGreaterSlantEqual = "⩾̸";
|
3887 | var NotGreaterTilde = "≵";
|
3888 | var NotHumpDownHump = "≎̸";
|
3889 | var NotHumpEqual = "≏̸";
|
3890 | var NotLeftTriangle = "⋪";
|
3891 | var NotLeftTriangleBar = "⧏̸";
|
3892 | var NotLeftTriangleEqual = "⋬";
|
3893 | var NotLess = "≮";
|
3894 | var NotLessEqual = "≰";
|
3895 | var NotLessGreater = "≸";
|
3896 | var NotLessLess = "≪̸";
|
3897 | var NotLessSlantEqual = "⩽̸";
|
3898 | var NotLessTilde = "≴";
|
3899 | var NotNestedGreaterGreater = "⪢̸";
|
3900 | var NotNestedLessLess = "⪡̸";
|
3901 | var NotPrecedes = "⊀";
|
3902 | var NotPrecedesEqual = "⪯̸";
|
3903 | var NotPrecedesSlantEqual = "⋠";
|
3904 | var NotReverseElement = "∌";
|
3905 | var NotRightTriangle = "⋫";
|
3906 | var NotRightTriangleBar = "⧐̸";
|
3907 | var NotRightTriangleEqual = "⋭";
|
3908 | var NotSquareSubset = "⊏̸";
|
3909 | var NotSquareSubsetEqual = "⋢";
|
3910 | var NotSquareSuperset = "⊐̸";
|
3911 | var NotSquareSupersetEqual = "⋣";
|
3912 | var NotSubset = "⊂⃒";
|
3913 | var NotSubsetEqual = "⊈";
|
3914 | var NotSucceeds = "⊁";
|
3915 | var NotSucceedsEqual = "⪰̸";
|
3916 | var NotSucceedsSlantEqual = "⋡";
|
3917 | var NotSucceedsTilde = "≿̸";
|
3918 | var NotSuperset = "⊃⃒";
|
3919 | var NotSupersetEqual = "⊉";
|
3920 | var NotTilde = "≁";
|
3921 | var NotTildeEqual = "≄";
|
3922 | var NotTildeFullEqual = "≇";
|
3923 | var NotTildeTilde = "≉";
|
3924 | var NotVerticalBar = "∤";
|
3925 | var Nscr = "𝒩";
|
3926 | var Ntild = "Ñ";
|
3927 | var Ntilde = "Ñ";
|
3928 | var Nu = "Ν";
|
3929 | var OElig = "Œ";
|
3930 | var Oacut = "Ó";
|
3931 | var Oacute = "Ó";
|
3932 | var Ocir = "Ô";
|
3933 | var Ocirc = "Ô";
|
3934 | var Ocy = "О";
|
3935 | var Odblac = "Ő";
|
3936 | var Ofr = "𝔒";
|
3937 | var Ograv = "Ò";
|
3938 | var Ograve = "Ò";
|
3939 | var Omacr = "Ō";
|
3940 | var Omega = "Ω";
|
3941 | var Omicron = "Ο";
|
3942 | var Oopf = "𝕆";
|
3943 | var OpenCurlyDoubleQuote = "“";
|
3944 | var OpenCurlyQuote = "‘";
|
3945 | var Or = "⩔";
|
3946 | var Oscr = "𝒪";
|
3947 | var Oslas = "Ø";
|
3948 | var Oslash = "Ø";
|
3949 | var Otild = "Õ";
|
3950 | var Otilde = "Õ";
|
3951 | var Otimes = "⨷";
|
3952 | var Oum = "Ö";
|
3953 | var Ouml = "Ö";
|
3954 | var OverBar = "‾";
|
3955 | var OverBrace = "⏞";
|
3956 | var OverBracket = "⎴";
|
3957 | var OverParenthesis = "⏜";
|
3958 | var PartialD = "∂";
|
3959 | var Pcy = "П";
|
3960 | var Pfr = "𝔓";
|
3961 | var Phi = "Φ";
|
3962 | var Pi = "Π";
|
3963 | var PlusMinus = "±";
|
3964 | var Poincareplane = "ℌ";
|
3965 | var Popf = "ℙ";
|
3966 | var Pr = "⪻";
|
3967 | var Precedes = "≺";
|
3968 | var PrecedesEqual = "⪯";
|
3969 | var PrecedesSlantEqual = "≼";
|
3970 | var PrecedesTilde = "≾";
|
3971 | var Prime = "″";
|
3972 | var Product = "∏";
|
3973 | var Proportion = "∷";
|
3974 | var Proportional = "∝";
|
3975 | var Pscr = "𝒫";
|
3976 | var Psi = "Ψ";
|
3977 | var QUO = "\"";
|
3978 | var QUOT = "\"";
|
3979 | var Qfr = "𝔔";
|
3980 | var Qopf = "ℚ";
|
3981 | var Qscr = "𝒬";
|
3982 | var RBarr = "⤐";
|
3983 | var RE = "®";
|
3984 | var REG = "®";
|
3985 | var Racute = "Ŕ";
|
3986 | var Rang = "⟫";
|
3987 | var Rarr = "↠";
|
3988 | var Rarrtl = "⤖";
|
3989 | var Rcaron = "Ř";
|
3990 | var Rcedil = "Ŗ";
|
3991 | var Rcy = "Р";
|
3992 | var Re = "ℜ";
|
3993 | var ReverseElement = "∋";
|
3994 | var ReverseEquilibrium = "⇋";
|
3995 | var ReverseUpEquilibrium = "⥯";
|
3996 | var Rfr = "ℜ";
|
3997 | var Rho = "Ρ";
|
3998 | var RightAngleBracket = "⟩";
|
3999 | var RightArrow = "→";
|
4000 | var RightArrowBar = "⇥";
|
4001 | var RightArrowLeftArrow = "⇄";
|
4002 | var RightCeiling = "⌉";
|
4003 | var RightDoubleBracket = "⟧";
|
4004 | var RightDownTeeVector = "⥝";
|
4005 | var RightDownVector = "⇂";
|
4006 | var RightDownVectorBar = "⥕";
|
4007 | var RightFloor = "⌋";
|
4008 | var RightTee = "⊢";
|
4009 | var RightTeeArrow = "↦";
|
4010 | var RightTeeVector = "⥛";
|
4011 | var RightTriangle = "⊳";
|
4012 | var RightTriangleBar = "⧐";
|
4013 | var RightTriangleEqual = "⊵";
|
4014 | var RightUpDownVector = "⥏";
|
4015 | var RightUpTeeVector = "⥜";
|
4016 | var RightUpVector = "↾";
|
4017 | var RightUpVectorBar = "⥔";
|
4018 | var RightVector = "⇀";
|
4019 | var RightVectorBar = "⥓";
|
4020 | var Rightarrow = "⇒";
|
4021 | var Ropf = "ℝ";
|
4022 | var RoundImplies = "⥰";
|
4023 | var Rrightarrow = "⇛";
|
4024 | var Rscr = "ℛ";
|
4025 | var Rsh = "↱";
|
4026 | var RuleDelayed = "⧴";
|
4027 | var SHCHcy = "Щ";
|
4028 | var SHcy = "Ш";
|
4029 | var SOFTcy = "Ь";
|
4030 | var Sacute = "Ś";
|
4031 | var Sc = "⪼";
|
4032 | var Scaron = "Š";
|
4033 | var Scedil = "Ş";
|
4034 | var Scirc = "Ŝ";
|
4035 | var Scy = "С";
|
4036 | var Sfr = "𝔖";
|
4037 | var ShortDownArrow = "↓";
|
4038 | var ShortLeftArrow = "←";
|
4039 | var ShortRightArrow = "→";
|
4040 | var ShortUpArrow = "↑";
|
4041 | var Sigma = "Σ";
|
4042 | var SmallCircle = "∘";
|
4043 | var Sopf = "𝕊";
|
4044 | var Sqrt = "√";
|
4045 | var Square = "□";
|
4046 | var SquareIntersection = "⊓";
|
4047 | var SquareSubset = "⊏";
|
4048 | var SquareSubsetEqual = "⊑";
|
4049 | var SquareSuperset = "⊐";
|
4050 | var SquareSupersetEqual = "⊒";
|
4051 | var SquareUnion = "⊔";
|
4052 | var Sscr = "𝒮";
|
4053 | var Star = "⋆";
|
4054 | var Sub = "⋐";
|
4055 | var Subset = "⋐";
|
4056 | var SubsetEqual = "⊆";
|
4057 | var Succeeds = "≻";
|
4058 | var SucceedsEqual = "⪰";
|
4059 | var SucceedsSlantEqual = "≽";
|
4060 | var SucceedsTilde = "≿";
|
4061 | var SuchThat = "∋";
|
4062 | var Sum = "∑";
|
4063 | var Sup = "⋑";
|
4064 | var Superset = "⊃";
|
4065 | var SupersetEqual = "⊇";
|
4066 | var Supset = "⋑";
|
4067 | var THOR = "Þ";
|
4068 | var THORN = "Þ";
|
4069 | var TRADE = "™";
|
4070 | var TSHcy = "Ћ";
|
4071 | var TScy = "Ц";
|
4072 | var Tab = "\t";
|
4073 | var Tau = "Τ";
|
4074 | var Tcaron = "Ť";
|
4075 | var Tcedil = "Ţ";
|
4076 | var Tcy = "Т";
|
4077 | var Tfr = "𝔗";
|
4078 | var Therefore = "∴";
|
4079 | var Theta = "Θ";
|
4080 | var ThickSpace = " ";
|
4081 | var ThinSpace = " ";
|
4082 | var Tilde = "∼";
|
4083 | var TildeEqual = "≃";
|
4084 | var TildeFullEqual = "≅";
|
4085 | var TildeTilde = "≈";
|
4086 | var Topf = "𝕋";
|
4087 | var TripleDot = "⃛";
|
4088 | var Tscr = "𝒯";
|
4089 | var Tstrok = "Ŧ";
|
4090 | var Uacut = "Ú";
|
4091 | var Uacute = "Ú";
|
4092 | var Uarr = "↟";
|
4093 | var Uarrocir = "⥉";
|
4094 | var Ubrcy = "Ў";
|
4095 | var Ubreve = "Ŭ";
|
4096 | var Ucir = "Û";
|
4097 | var Ucirc = "Û";
|
4098 | var Ucy = "У";
|
4099 | var Udblac = "Ű";
|
4100 | var Ufr = "𝔘";
|
4101 | var Ugrav = "Ù";
|
4102 | var Ugrave = "Ù";
|
4103 | var Umacr = "Ū";
|
4104 | var UnderBar = "_";
|
4105 | var UnderBrace = "⏟";
|
4106 | var UnderBracket = "⎵";
|
4107 | var UnderParenthesis = "⏝";
|
4108 | var Union = "⋃";
|
4109 | var UnionPlus = "⊎";
|
4110 | var Uogon = "Ų";
|
4111 | var Uopf = "𝕌";
|
4112 | var UpArrow = "↑";
|
4113 | var UpArrowBar = "⤒";
|
4114 | var UpArrowDownArrow = "⇅";
|
4115 | var UpDownArrow = "↕";
|
4116 | var UpEquilibrium = "⥮";
|
4117 | var UpTee = "⊥";
|
4118 | var UpTeeArrow = "↥";
|
4119 | var Uparrow = "⇑";
|
4120 | var Updownarrow = "⇕";
|
4121 | var UpperLeftArrow = "↖";
|
4122 | var UpperRightArrow = "↗";
|
4123 | var Upsi = "ϒ";
|
4124 | var Upsilon = "Υ";
|
4125 | var Uring = "Ů";
|
4126 | var Uscr = "𝒰";
|
4127 | var Utilde = "Ũ";
|
4128 | var Uum = "Ü";
|
4129 | var Uuml = "Ü";
|
4130 | var VDash = "⊫";
|
4131 | var Vbar = "⫫";
|
4132 | var Vcy = "В";
|
4133 | var Vdash = "⊩";
|
4134 | var Vdashl = "⫦";
|
4135 | var Vee = "⋁";
|
4136 | var Verbar = "‖";
|
4137 | var Vert = "‖";
|
4138 | var VerticalBar = "∣";
|
4139 | var VerticalLine = "|";
|
4140 | var VerticalSeparator = "❘";
|
4141 | var VerticalTilde = "≀";
|
4142 | var VeryThinSpace = " ";
|
4143 | var Vfr = "𝔙";
|
4144 | var Vopf = "𝕍";
|
4145 | var Vscr = "𝒱";
|
4146 | var Vvdash = "⊪";
|
4147 | var Wcirc = "Ŵ";
|
4148 | var Wedge = "⋀";
|
4149 | var Wfr = "𝔚";
|
4150 | var Wopf = "𝕎";
|
4151 | var Wscr = "𝒲";
|
4152 | var Xfr = "𝔛";
|
4153 | var Xi = "Ξ";
|
4154 | var Xopf = "𝕏";
|
4155 | var Xscr = "𝒳";
|
4156 | var YAcy = "Я";
|
4157 | var YIcy = "Ї";
|
4158 | var YUcy = "Ю";
|
4159 | var Yacut = "Ý";
|
4160 | var Yacute = "Ý";
|
4161 | var Ycirc = "Ŷ";
|
4162 | var Ycy = "Ы";
|
4163 | var Yfr = "𝔜";
|
4164 | var Yopf = "𝕐";
|
4165 | var Yscr = "𝒴";
|
4166 | var Yuml = "Ÿ";
|
4167 | var ZHcy = "Ж";
|
4168 | var Zacute = "Ź";
|
4169 | var Zcaron = "Ž";
|
4170 | var Zcy = "З";
|
4171 | var Zdot = "Ż";
|
4172 | var ZeroWidthSpace = "";
|
4173 | var Zeta = "Ζ";
|
4174 | var Zfr = "ℨ";
|
4175 | var Zopf = "ℤ";
|
4176 | var Zscr = "𝒵";
|
4177 | var aacut = "á";
|
4178 | var aacute = "á";
|
4179 | var abreve = "ă";
|
4180 | var ac = "∾";
|
4181 | var acE = "∾̳";
|
4182 | var acd = "∿";
|
4183 | var acir = "â";
|
4184 | var acirc = "â";
|
4185 | var acut = "´";
|
4186 | var acute = "´";
|
4187 | var acy = "а";
|
4188 | var aeli = "æ";
|
4189 | var aelig = "æ";
|
4190 | var af = "";
|
4191 | var afr = "𝔞";
|
4192 | var agrav = "à";
|
4193 | var agrave = "à";
|
4194 | var alefsym = "ℵ";
|
4195 | var aleph = "ℵ";
|
4196 | var alpha = "α";
|
4197 | var amacr = "ā";
|
4198 | var amalg = "⨿";
|
4199 | var am = "&";
|
4200 | var amp = "&";
|
4201 | var and = "∧";
|
4202 | var andand = "⩕";
|
4203 | var andd = "⩜";
|
4204 | var andslope = "⩘";
|
4205 | var andv = "⩚";
|
4206 | var ang = "∠";
|
4207 | var ange = "⦤";
|
4208 | var angle = "∠";
|
4209 | var angmsd = "∡";
|
4210 | var angmsdaa = "⦨";
|
4211 | var angmsdab = "⦩";
|
4212 | var angmsdac = "⦪";
|
4213 | var angmsdad = "⦫";
|
4214 | var angmsdae = "⦬";
|
4215 | var angmsdaf = "⦭";
|
4216 | var angmsdag = "⦮";
|
4217 | var angmsdah = "⦯";
|
4218 | var angrt = "∟";
|
4219 | var angrtvb = "⊾";
|
4220 | var angrtvbd = "⦝";
|
4221 | var angsph = "∢";
|
4222 | var angst = "Å";
|
4223 | var angzarr = "⍼";
|
4224 | var aogon = "ą";
|
4225 | var aopf = "𝕒";
|
4226 | var ap = "≈";
|
4227 | var apE = "⩰";
|
4228 | var apacir = "⩯";
|
4229 | var ape = "≊";
|
4230 | var apid = "≋";
|
4231 | var apos = "'";
|
4232 | var approx = "≈";
|
4233 | var approxeq = "≊";
|
4234 | var arin = "å";
|
4235 | var aring = "å";
|
4236 | var ascr = "𝒶";
|
4237 | var ast = "*";
|
4238 | var asymp = "≈";
|
4239 | var asympeq = "≍";
|
4240 | var atild = "ã";
|
4241 | var atilde = "ã";
|
4242 | var aum = "ä";
|
4243 | var auml = "ä";
|
4244 | var awconint = "∳";
|
4245 | var awint = "⨑";
|
4246 | var bNot = "⫭";
|
4247 | var backcong = "≌";
|
4248 | var backepsilon = "϶";
|
4249 | var backprime = "‵";
|
4250 | var backsim = "∽";
|
4251 | var backsimeq = "⋍";
|
4252 | var barvee = "⊽";
|
4253 | var barwed = "⌅";
|
4254 | var barwedge = "⌅";
|
4255 | var bbrk = "⎵";
|
4256 | var bbrktbrk = "⎶";
|
4257 | var bcong = "≌";
|
4258 | var bcy = "б";
|
4259 | var bdquo = "„";
|
4260 | var becaus = "∵";
|
4261 | var because = "∵";
|
4262 | var bemptyv = "⦰";
|
4263 | var bepsi = "϶";
|
4264 | var bernou = "ℬ";
|
4265 | var beta = "β";
|
4266 | var beth = "ℶ";
|
4267 | var between = "≬";
|
4268 | var bfr = "𝔟";
|
4269 | var bigcap = "⋂";
|
4270 | var bigcirc = "◯";
|
4271 | var bigcup = "⋃";
|
4272 | var bigodot = "⨀";
|
4273 | var bigoplus = "⨁";
|
4274 | var bigotimes = "⨂";
|
4275 | var bigsqcup = "⨆";
|
4276 | var bigstar = "★";
|
4277 | var bigtriangledown = "▽";
|
4278 | var bigtriangleup = "△";
|
4279 | var biguplus = "⨄";
|
4280 | var bigvee = "⋁";
|
4281 | var bigwedge = "⋀";
|
4282 | var bkarow = "⤍";
|
4283 | var blacklozenge = "⧫";
|
4284 | var blacksquare = "▪";
|
4285 | var blacktriangle = "▴";
|
4286 | var blacktriangledown = "▾";
|
4287 | var blacktriangleleft = "◂";
|
4288 | var blacktriangleright = "▸";
|
4289 | var blank = "␣";
|
4290 | var blk12 = "▒";
|
4291 | var blk14 = "░";
|
4292 | var blk34 = "▓";
|
4293 | var block = "█";
|
4294 | var bne = "=⃥";
|
4295 | var bnequiv = "≡⃥";
|
4296 | var bnot = "⌐";
|
4297 | var bopf = "𝕓";
|
4298 | var bot = "⊥";
|
4299 | var bottom = "⊥";
|
4300 | var bowtie = "⋈";
|
4301 | var boxDL = "╗";
|
4302 | var boxDR = "╔";
|
4303 | var boxDl = "╖";
|
4304 | var boxDr = "╓";
|
4305 | var boxH = "═";
|
4306 | var boxHD = "╦";
|
4307 | var boxHU = "╩";
|
4308 | var boxHd = "╤";
|
4309 | var boxHu = "╧";
|
4310 | var boxUL = "╝";
|
4311 | var boxUR = "╚";
|
4312 | var boxUl = "╜";
|
4313 | var boxUr = "╙";
|
4314 | var boxV = "║";
|
4315 | var boxVH = "╬";
|
4316 | var boxVL = "╣";
|
4317 | var boxVR = "╠";
|
4318 | var boxVh = "╫";
|
4319 | var boxVl = "╢";
|
4320 | var boxVr = "╟";
|
4321 | var boxbox = "⧉";
|
4322 | var boxdL = "╕";
|
4323 | var boxdR = "╒";
|
4324 | var boxdl = "┐";
|
4325 | var boxdr = "┌";
|
4326 | var boxh = "─";
|
4327 | var boxhD = "╥";
|
4328 | var boxhU = "╨";
|
4329 | var boxhd = "┬";
|
4330 | var boxhu = "┴";
|
4331 | var boxminus = "⊟";
|
4332 | var boxplus = "⊞";
|
4333 | var boxtimes = "⊠";
|
4334 | var boxuL = "╛";
|
4335 | var boxuR = "╘";
|
4336 | var boxul = "┘";
|
4337 | var boxur = "└";
|
4338 | var boxv = "│";
|
4339 | var boxvH = "╪";
|
4340 | var boxvL = "╡";
|
4341 | var boxvR = "╞";
|
4342 | var boxvh = "┼";
|
4343 | var boxvl = "┤";
|
4344 | var boxvr = "├";
|
4345 | var bprime = "‵";
|
4346 | var breve = "˘";
|
4347 | var brvba = "¦";
|
4348 | var brvbar = "¦";
|
4349 | var bscr = "𝒷";
|
4350 | var bsemi = "⁏";
|
4351 | var bsim = "∽";
|
4352 | var bsime = "⋍";
|
4353 | var bsol = "\\";
|
4354 | var bsolb = "⧅";
|
4355 | var bsolhsub = "⟈";
|
4356 | var bull = "•";
|
4357 | var bullet = "•";
|
4358 | var bump = "≎";
|
4359 | var bumpE = "⪮";
|
4360 | var bumpe = "≏";
|
4361 | var bumpeq = "≏";
|
4362 | var cacute = "ć";
|
4363 | var cap = "∩";
|
4364 | var capand = "⩄";
|
4365 | var capbrcup = "⩉";
|
4366 | var capcap = "⩋";
|
4367 | var capcup = "⩇";
|
4368 | var capdot = "⩀";
|
4369 | var caps = "∩︀";
|
4370 | var caret = "⁁";
|
4371 | var caron = "ˇ";
|
4372 | var ccaps = "⩍";
|
4373 | var ccaron = "č";
|
4374 | var ccedi = "ç";
|
4375 | var ccedil = "ç";
|
4376 | var ccirc = "ĉ";
|
4377 | var ccups = "⩌";
|
4378 | var ccupssm = "⩐";
|
4379 | var cdot = "ċ";
|
4380 | var cedi = "¸";
|
4381 | var cedil = "¸";
|
4382 | var cemptyv = "⦲";
|
4383 | var cen = "¢";
|
4384 | var cent = "¢";
|
4385 | var centerdot = "·";
|
4386 | var cfr = "𝔠";
|
4387 | var chcy = "ч";
|
4388 | var check = "✓";
|
4389 | var checkmark = "✓";
|
4390 | var chi = "χ";
|
4391 | var cir = "○";
|
4392 | var cirE = "⧃";
|
4393 | var circ = "ˆ";
|
4394 | var circeq = "≗";
|
4395 | var circlearrowleft = "↺";
|
4396 | var circlearrowright = "↻";
|
4397 | var circledR = "®";
|
4398 | var circledS = "Ⓢ";
|
4399 | var circledast = "⊛";
|
4400 | var circledcirc = "⊚";
|
4401 | var circleddash = "⊝";
|
4402 | var cire = "≗";
|
4403 | var cirfnint = "⨐";
|
4404 | var cirmid = "⫯";
|
4405 | var cirscir = "⧂";
|
4406 | var clubs = "♣";
|
4407 | var clubsuit = "♣";
|
4408 | var colon = ":";
|
4409 | var colone = "≔";
|
4410 | var coloneq = "≔";
|
4411 | var comma = ",";
|
4412 | var commat = "@";
|
4413 | var comp = "∁";
|
4414 | var compfn = "∘";
|
4415 | var complement = "∁";
|
4416 | var complexes = "ℂ";
|
4417 | var cong = "≅";
|
4418 | var congdot = "⩭";
|
4419 | var conint = "∮";
|
4420 | var copf = "𝕔";
|
4421 | var coprod = "∐";
|
4422 | var cop = "©";
|
4423 | var copy = "©";
|
4424 | var copysr = "℗";
|
4425 | var crarr = "↵";
|
4426 | var cross = "✗";
|
4427 | var cscr = "𝒸";
|
4428 | var csub = "⫏";
|
4429 | var csube = "⫑";
|
4430 | var csup = "⫐";
|
4431 | var csupe = "⫒";
|
4432 | var ctdot = "⋯";
|
4433 | var cudarrl = "⤸";
|
4434 | var cudarrr = "⤵";
|
4435 | var cuepr = "⋞";
|
4436 | var cuesc = "⋟";
|
4437 | var cularr = "↶";
|
4438 | var cularrp = "⤽";
|
4439 | var cup = "∪";
|
4440 | var cupbrcap = "⩈";
|
4441 | var cupcap = "⩆";
|
4442 | var cupcup = "⩊";
|
4443 | var cupdot = "⊍";
|
4444 | var cupor = "⩅";
|
4445 | var cups = "∪︀";
|
4446 | var curarr = "↷";
|
4447 | var curarrm = "⤼";
|
4448 | var curlyeqprec = "⋞";
|
4449 | var curlyeqsucc = "⋟";
|
4450 | var curlyvee = "⋎";
|
4451 | var curlywedge = "⋏";
|
4452 | var curre = "¤";
|
4453 | var curren = "¤";
|
4454 | var curvearrowleft = "↶";
|
4455 | var curvearrowright = "↷";
|
4456 | var cuvee = "⋎";
|
4457 | var cuwed = "⋏";
|
4458 | var cwconint = "∲";
|
4459 | var cwint = "∱";
|
4460 | var cylcty = "⌭";
|
4461 | var dArr = "⇓";
|
4462 | var dHar = "⥥";
|
4463 | var dagger = "†";
|
4464 | var daleth = "ℸ";
|
4465 | var darr = "↓";
|
4466 | var dash = "‐";
|
4467 | var dashv = "⊣";
|
4468 | var dbkarow = "⤏";
|
4469 | var dblac = "˝";
|
4470 | var dcaron = "ď";
|
4471 | var dcy = "д";
|
4472 | var dd = "ⅆ";
|
4473 | var ddagger = "‡";
|
4474 | var ddarr = "⇊";
|
4475 | var ddotseq = "⩷";
|
4476 | var de = "°";
|
4477 | var deg = "°";
|
4478 | var delta = "δ";
|
4479 | var demptyv = "⦱";
|
4480 | var dfisht = "⥿";
|
4481 | var dfr = "𝔡";
|
4482 | var dharl = "⇃";
|
4483 | var dharr = "⇂";
|
4484 | var diam = "⋄";
|
4485 | var diamond = "⋄";
|
4486 | var diamondsuit = "♦";
|
4487 | var diams = "♦";
|
4488 | var die = "¨";
|
4489 | var digamma = "ϝ";
|
4490 | var disin = "⋲";
|
4491 | var div = "÷";
|
4492 | var divid = "÷";
|
4493 | var divide = "÷";
|
4494 | var divideontimes = "⋇";
|
4495 | var divonx = "⋇";
|
4496 | var djcy = "ђ";
|
4497 | var dlcorn = "⌞";
|
4498 | var dlcrop = "⌍";
|
4499 | var dollar = "$";
|
4500 | var dopf = "𝕕";
|
4501 | var dot = "˙";
|
4502 | var doteq = "≐";
|
4503 | var doteqdot = "≑";
|
4504 | var dotminus = "∸";
|
4505 | var dotplus = "∔";
|
4506 | var dotsquare = "⊡";
|
4507 | var doublebarwedge = "⌆";
|
4508 | var downarrow = "↓";
|
4509 | var downdownarrows = "⇊";
|
4510 | var downharpoonleft = "⇃";
|
4511 | var downharpoonright = "⇂";
|
4512 | var drbkarow = "⤐";
|
4513 | var drcorn = "⌟";
|
4514 | var drcrop = "⌌";
|
4515 | var dscr = "𝒹";
|
4516 | var dscy = "ѕ";
|
4517 | var dsol = "⧶";
|
4518 | var dstrok = "đ";
|
4519 | var dtdot = "⋱";
|
4520 | var dtri = "▿";
|
4521 | var dtrif = "▾";
|
4522 | var duarr = "⇵";
|
4523 | var duhar = "⥯";
|
4524 | var dwangle = "⦦";
|
4525 | var dzcy = "џ";
|
4526 | var dzigrarr = "⟿";
|
4527 | var eDDot = "⩷";
|
4528 | var eDot = "≑";
|
4529 | var eacut = "é";
|
4530 | var eacute = "é";
|
4531 | var easter = "⩮";
|
4532 | var ecaron = "ě";
|
4533 | var ecir = "ê";
|
4534 | var ecirc = "ê";
|
4535 | var ecolon = "≕";
|
4536 | var ecy = "э";
|
4537 | var edot = "ė";
|
4538 | var ee = "ⅇ";
|
4539 | var efDot = "≒";
|
4540 | var efr = "𝔢";
|
4541 | var eg = "⪚";
|
4542 | var egrav = "è";
|
4543 | var egrave = "è";
|
4544 | var egs = "⪖";
|
4545 | var egsdot = "⪘";
|
4546 | var el = "⪙";
|
4547 | var elinters = "⏧";
|
4548 | var ell = "ℓ";
|
4549 | var els = "⪕";
|
4550 | var elsdot = "⪗";
|
4551 | var emacr = "ē";
|
4552 | var empty = "∅";
|
4553 | var emptyset = "∅";
|
4554 | var emptyv = "∅";
|
4555 | var emsp13 = " ";
|
4556 | var emsp14 = " ";
|
4557 | var emsp = " ";
|
4558 | var eng = "ŋ";
|
4559 | var ensp = " ";
|
4560 | var eogon = "ę";
|
4561 | var eopf = "𝕖";
|
4562 | var epar = "⋕";
|
4563 | var eparsl = "⧣";
|
4564 | var eplus = "⩱";
|
4565 | var epsi = "ε";
|
4566 | var epsilon = "ε";
|
4567 | var epsiv = "ϵ";
|
4568 | var eqcirc = "≖";
|
4569 | var eqcolon = "≕";
|
4570 | var eqsim = "≂";
|
4571 | var eqslantgtr = "⪖";
|
4572 | var eqslantless = "⪕";
|
4573 | var equals = "=";
|
4574 | var equest = "≟";
|
4575 | var equiv = "≡";
|
4576 | var equivDD = "⩸";
|
4577 | var eqvparsl = "⧥";
|
4578 | var erDot = "≓";
|
4579 | var erarr = "⥱";
|
4580 | var escr = "ℯ";
|
4581 | var esdot = "≐";
|
4582 | var esim = "≂";
|
4583 | var eta = "η";
|
4584 | var et = "ð";
|
4585 | var eth = "ð";
|
4586 | var eum = "ë";
|
4587 | var euml = "ë";
|
4588 | var euro = "€";
|
4589 | var excl = "!";
|
4590 | var exist = "∃";
|
4591 | var expectation = "ℰ";
|
4592 | var exponentiale = "ⅇ";
|
4593 | var fallingdotseq = "≒";
|
4594 | var fcy = "ф";
|
4595 | var female = "♀";
|
4596 | var ffilig = "ffi";
|
4597 | var fflig = "ff";
|
4598 | var ffllig = "ffl";
|
4599 | var ffr = "𝔣";
|
4600 | var filig = "fi";
|
4601 | var fjlig = "fj";
|
4602 | var flat = "♭";
|
4603 | var fllig = "fl";
|
4604 | var fltns = "▱";
|
4605 | var fnof = "ƒ";
|
4606 | var fopf = "𝕗";
|
4607 | var forall = "∀";
|
4608 | var fork = "⋔";
|
4609 | var forkv = "⫙";
|
4610 | var fpartint = "⨍";
|
4611 | var frac1 = "¼";
|
4612 | var frac12 = "½";
|
4613 | var frac13 = "⅓";
|
4614 | var frac14 = "¼";
|
4615 | var frac15 = "⅕";
|
4616 | var frac16 = "⅙";
|
4617 | var frac18 = "⅛";
|
4618 | var frac23 = "⅔";
|
4619 | var frac25 = "⅖";
|
4620 | var frac3 = "¾";
|
4621 | var frac34 = "¾";
|
4622 | var frac35 = "⅗";
|
4623 | var frac38 = "⅜";
|
4624 | var frac45 = "⅘";
|
4625 | var frac56 = "⅚";
|
4626 | var frac58 = "⅝";
|
4627 | var frac78 = "⅞";
|
4628 | var frasl = "⁄";
|
4629 | var frown = "⌢";
|
4630 | var fscr = "𝒻";
|
4631 | var gE = "≧";
|
4632 | var gEl = "⪌";
|
4633 | var gacute = "ǵ";
|
4634 | var gamma = "γ";
|
4635 | var gammad = "ϝ";
|
4636 | var gap = "⪆";
|
4637 | var gbreve = "ğ";
|
4638 | var gcirc = "ĝ";
|
4639 | var gcy = "г";
|
4640 | var gdot = "ġ";
|
4641 | var ge = "≥";
|
4642 | var gel = "⋛";
|
4643 | var geq = "≥";
|
4644 | var geqq = "≧";
|
4645 | var geqslant = "⩾";
|
4646 | var ges = "⩾";
|
4647 | var gescc = "⪩";
|
4648 | var gesdot = "⪀";
|
4649 | var gesdoto = "⪂";
|
4650 | var gesdotol = "⪄";
|
4651 | var gesl = "⋛︀";
|
4652 | var gesles = "⪔";
|
4653 | var gfr = "𝔤";
|
4654 | var gg = "≫";
|
4655 | var ggg = "⋙";
|
4656 | var gimel = "ℷ";
|
4657 | var gjcy = "ѓ";
|
4658 | var gl = "≷";
|
4659 | var glE = "⪒";
|
4660 | var gla = "⪥";
|
4661 | var glj = "⪤";
|
4662 | var gnE = "≩";
|
4663 | var gnap = "⪊";
|
4664 | var gnapprox = "⪊";
|
4665 | var gne = "⪈";
|
4666 | var gneq = "⪈";
|
4667 | var gneqq = "≩";
|
4668 | var gnsim = "⋧";
|
4669 | var gopf = "𝕘";
|
4670 | var grave = "`";
|
4671 | var gscr = "ℊ";
|
4672 | var gsim = "≳";
|
4673 | var gsime = "⪎";
|
4674 | var gsiml = "⪐";
|
4675 | var g = ">";
|
4676 | var gt = ">";
|
4677 | var gtcc = "⪧";
|
4678 | var gtcir = "⩺";
|
4679 | var gtdot = "⋗";
|
4680 | var gtlPar = "⦕";
|
4681 | var gtquest = "⩼";
|
4682 | var gtrapprox = "⪆";
|
4683 | var gtrarr = "⥸";
|
4684 | var gtrdot = "⋗";
|
4685 | var gtreqless = "⋛";
|
4686 | var gtreqqless = "⪌";
|
4687 | var gtrless = "≷";
|
4688 | var gtrsim = "≳";
|
4689 | var gvertneqq = "≩︀";
|
4690 | var gvnE = "≩︀";
|
4691 | var hArr = "⇔";
|
4692 | var hairsp = " ";
|
4693 | var half = "½";
|
4694 | var hamilt = "ℋ";
|
4695 | var hardcy = "ъ";
|
4696 | var harr = "↔";
|
4697 | var harrcir = "⥈";
|
4698 | var harrw = "↭";
|
4699 | var hbar = "ℏ";
|
4700 | var hcirc = "ĥ";
|
4701 | var hearts = "♥";
|
4702 | var heartsuit = "♥";
|
4703 | var hellip = "…";
|
4704 | var hercon = "⊹";
|
4705 | var hfr = "𝔥";
|
4706 | var hksearow = "⤥";
|
4707 | var hkswarow = "⤦";
|
4708 | var hoarr = "⇿";
|
4709 | var homtht = "∻";
|
4710 | var hookleftarrow = "↩";
|
4711 | var hookrightarrow = "↪";
|
4712 | var hopf = "𝕙";
|
4713 | var horbar = "―";
|
4714 | var hscr = "𝒽";
|
4715 | var hslash = "ℏ";
|
4716 | var hstrok = "ħ";
|
4717 | var hybull = "⁃";
|
4718 | var hyphen = "‐";
|
4719 | var iacut = "í";
|
4720 | var iacute = "í";
|
4721 | var ic = "";
|
4722 | var icir = "î";
|
4723 | var icirc = "î";
|
4724 | var icy = "и";
|
4725 | var iecy = "е";
|
4726 | var iexc = "¡";
|
4727 | var iexcl = "¡";
|
4728 | var iff = "⇔";
|
4729 | var ifr = "𝔦";
|
4730 | var igrav = "ì";
|
4731 | var igrave = "ì";
|
4732 | var ii = "ⅈ";
|
4733 | var iiiint = "⨌";
|
4734 | var iiint = "∭";
|
4735 | var iinfin = "⧜";
|
4736 | var iiota = "℩";
|
4737 | var ijlig = "ij";
|
4738 | var imacr = "ī";
|
4739 | var image = "ℑ";
|
4740 | var imagline = "ℐ";
|
4741 | var imagpart = "ℑ";
|
4742 | var imath = "ı";
|
4743 | var imof = "⊷";
|
4744 | var imped = "Ƶ";
|
4745 | var incare = "℅";
|
4746 | var infin = "∞";
|
4747 | var infintie = "⧝";
|
4748 | var inodot = "ı";
|
4749 | var int = "∫";
|
4750 | var intcal = "⊺";
|
4751 | var integers = "ℤ";
|
4752 | var intercal = "⊺";
|
4753 | var intlarhk = "⨗";
|
4754 | var intprod = "⨼";
|
4755 | var iocy = "ё";
|
4756 | var iogon = "į";
|
4757 | var iopf = "𝕚";
|
4758 | var iota = "ι";
|
4759 | var iprod = "⨼";
|
4760 | var iques = "¿";
|
4761 | var iquest = "¿";
|
4762 | var iscr = "𝒾";
|
4763 | var isin = "∈";
|
4764 | var isinE = "⋹";
|
4765 | var isindot = "⋵";
|
4766 | var isins = "⋴";
|
4767 | var isinsv = "⋳";
|
4768 | var isinv = "∈";
|
4769 | var it = "";
|
4770 | var itilde = "ĩ";
|
4771 | var iukcy = "і";
|
4772 | var ium = "ï";
|
4773 | var iuml = "ï";
|
4774 | var jcirc = "ĵ";
|
4775 | var jcy = "й";
|
4776 | var jfr = "𝔧";
|
4777 | var jmath = "ȷ";
|
4778 | var jopf = "𝕛";
|
4779 | var jscr = "𝒿";
|
4780 | var jsercy = "ј";
|
4781 | var jukcy = "є";
|
4782 | var kappa = "κ";
|
4783 | var kappav = "ϰ";
|
4784 | var kcedil = "ķ";
|
4785 | var kcy = "к";
|
4786 | var kfr = "𝔨";
|
4787 | var kgreen = "ĸ";
|
4788 | var khcy = "х";
|
4789 | var kjcy = "ќ";
|
4790 | var kopf = "𝕜";
|
4791 | var kscr = "𝓀";
|
4792 | var lAarr = "⇚";
|
4793 | var lArr = "⇐";
|
4794 | var lAtail = "⤛";
|
4795 | var lBarr = "⤎";
|
4796 | var lE = "≦";
|
4797 | var lEg = "⪋";
|
4798 | var lHar = "⥢";
|
4799 | var lacute = "ĺ";
|
4800 | var laemptyv = "⦴";
|
4801 | var lagran = "ℒ";
|
4802 | var lambda = "λ";
|
4803 | var lang = "⟨";
|
4804 | var langd = "⦑";
|
4805 | var langle = "⟨";
|
4806 | var lap = "⪅";
|
4807 | var laqu = "«";
|
4808 | var laquo = "«";
|
4809 | var larr = "←";
|
4810 | var larrb = "⇤";
|
4811 | var larrbfs = "⤟";
|
4812 | var larrfs = "⤝";
|
4813 | var larrhk = "↩";
|
4814 | var larrlp = "↫";
|
4815 | var larrpl = "⤹";
|
4816 | var larrsim = "⥳";
|
4817 | var larrtl = "↢";
|
4818 | var lat = "⪫";
|
4819 | var latail = "⤙";
|
4820 | var late = "⪭";
|
4821 | var lates = "⪭︀";
|
4822 | var lbarr = "⤌";
|
4823 | var lbbrk = "❲";
|
4824 | var lbrace = "{";
|
4825 | var lbrack = "[";
|
4826 | var lbrke = "⦋";
|
4827 | var lbrksld = "⦏";
|
4828 | var lbrkslu = "⦍";
|
4829 | var lcaron = "ľ";
|
4830 | var lcedil = "ļ";
|
4831 | var lceil = "⌈";
|
4832 | var lcub = "{";
|
4833 | var lcy = "л";
|
4834 | var ldca = "⤶";
|
4835 | var ldquo = "“";
|
4836 | var ldquor = "„";
|
4837 | var ldrdhar = "⥧";
|
4838 | var ldrushar = "⥋";
|
4839 | var ldsh = "↲";
|
4840 | var le = "≤";
|
4841 | var leftarrow = "←";
|
4842 | var leftarrowtail = "↢";
|
4843 | var leftharpoondown = "↽";
|
4844 | var leftharpoonup = "↼";
|
4845 | var leftleftarrows = "⇇";
|
4846 | var leftrightarrow = "↔";
|
4847 | var leftrightarrows = "⇆";
|
4848 | var leftrightharpoons = "⇋";
|
4849 | var leftrightsquigarrow = "↭";
|
4850 | var leftthreetimes = "⋋";
|
4851 | var leg = "⋚";
|
4852 | var leq = "≤";
|
4853 | var leqq = "≦";
|
4854 | var leqslant = "⩽";
|
4855 | var les = "⩽";
|
4856 | var lescc = "⪨";
|
4857 | var lesdot = "⩿";
|
4858 | var lesdoto = "⪁";
|
4859 | var lesdotor = "⪃";
|
4860 | var lesg = "⋚︀";
|
4861 | var lesges = "⪓";
|
4862 | var lessapprox = "⪅";
|
4863 | var lessdot = "⋖";
|
4864 | var lesseqgtr = "⋚";
|
4865 | var lesseqqgtr = "⪋";
|
4866 | var lessgtr = "≶";
|
4867 | var lesssim = "≲";
|
4868 | var lfisht = "⥼";
|
4869 | var lfloor = "⌊";
|
4870 | var lfr = "𝔩";
|
4871 | var lg = "≶";
|
4872 | var lgE = "⪑";
|
4873 | var lhard = "↽";
|
4874 | var lharu = "↼";
|
4875 | var lharul = "⥪";
|
4876 | var lhblk = "▄";
|
4877 | var ljcy = "љ";
|
4878 | var ll = "≪";
|
4879 | var llarr = "⇇";
|
4880 | var llcorner = "⌞";
|
4881 | var llhard = "⥫";
|
4882 | var lltri = "◺";
|
4883 | var lmidot = "ŀ";
|
4884 | var lmoust = "⎰";
|
4885 | var lmoustache = "⎰";
|
4886 | var lnE = "≨";
|
4887 | var lnap = "⪉";
|
4888 | var lnapprox = "⪉";
|
4889 | var lne = "⪇";
|
4890 | var lneq = "⪇";
|
4891 | var lneqq = "≨";
|
4892 | var lnsim = "⋦";
|
4893 | var loang = "⟬";
|
4894 | var loarr = "⇽";
|
4895 | var lobrk = "⟦";
|
4896 | var longleftarrow = "⟵";
|
4897 | var longleftrightarrow = "⟷";
|
4898 | var longmapsto = "⟼";
|
4899 | var longrightarrow = "⟶";
|
4900 | var looparrowleft = "↫";
|
4901 | var looparrowright = "↬";
|
4902 | var lopar = "⦅";
|
4903 | var lopf = "𝕝";
|
4904 | var loplus = "⨭";
|
4905 | var lotimes = "⨴";
|
4906 | var lowast = "∗";
|
4907 | var lowbar = "_";
|
4908 | var loz = "◊";
|
4909 | var lozenge = "◊";
|
4910 | var lozf = "⧫";
|
4911 | var lpar = "(";
|
4912 | var lparlt = "⦓";
|
4913 | var lrarr = "⇆";
|
4914 | var lrcorner = "⌟";
|
4915 | var lrhar = "⇋";
|
4916 | var lrhard = "⥭";
|
4917 | var lrm = "";
|
4918 | var lrtri = "⊿";
|
4919 | var lsaquo = "‹";
|
4920 | var lscr = "𝓁";
|
4921 | var lsh = "↰";
|
4922 | var lsim = "≲";
|
4923 | var lsime = "⪍";
|
4924 | var lsimg = "⪏";
|
4925 | var lsqb = "[";
|
4926 | var lsquo = "‘";
|
4927 | var lsquor = "‚";
|
4928 | var lstrok = "ł";
|
4929 | var l = "<";
|
4930 | var lt = "<";
|
4931 | var ltcc = "⪦";
|
4932 | var ltcir = "⩹";
|
4933 | var ltdot = "⋖";
|
4934 | var lthree = "⋋";
|
4935 | var ltimes = "⋉";
|
4936 | var ltlarr = "⥶";
|
4937 | var ltquest = "⩻";
|
4938 | var ltrPar = "⦖";
|
4939 | var ltri = "◃";
|
4940 | var ltrie = "⊴";
|
4941 | var ltrif = "◂";
|
4942 | var lurdshar = "⥊";
|
4943 | var luruhar = "⥦";
|
4944 | var lvertneqq = "≨︀";
|
4945 | var lvnE = "≨︀";
|
4946 | var mDDot = "∺";
|
4947 | var mac = "¯";
|
4948 | var macr = "¯";
|
4949 | var male = "♂";
|
4950 | var malt = "✠";
|
4951 | var maltese = "✠";
|
4952 | var map = "↦";
|
4953 | var mapsto = "↦";
|
4954 | var mapstodown = "↧";
|
4955 | var mapstoleft = "↤";
|
4956 | var mapstoup = "↥";
|
4957 | var marker = "▮";
|
4958 | var mcomma = "⨩";
|
4959 | var mcy = "м";
|
4960 | var mdash = "—";
|
4961 | var measuredangle = "∡";
|
4962 | var mfr = "𝔪";
|
4963 | var mho = "℧";
|
4964 | var micr = "µ";
|
4965 | var micro = "µ";
|
4966 | var mid = "∣";
|
4967 | var midast = "*";
|
4968 | var midcir = "⫰";
|
4969 | var middo = "·";
|
4970 | var middot = "·";
|
4971 | var minus = "−";
|
4972 | var minusb = "⊟";
|
4973 | var minusd = "∸";
|
4974 | var minusdu = "⨪";
|
4975 | var mlcp = "⫛";
|
4976 | var mldr = "…";
|
4977 | var mnplus = "∓";
|
4978 | var models = "⊧";
|
4979 | var mopf = "𝕞";
|
4980 | var mp = "∓";
|
4981 | var mscr = "𝓂";
|
4982 | var mstpos = "∾";
|
4983 | var mu = "μ";
|
4984 | var multimap = "⊸";
|
4985 | var mumap = "⊸";
|
4986 | var nGg = "⋙̸";
|
4987 | var nGt = "≫⃒";
|
4988 | var nGtv = "≫̸";
|
4989 | var nLeftarrow = "⇍";
|
4990 | var nLeftrightarrow = "⇎";
|
4991 | var nLl = "⋘̸";
|
4992 | var nLt = "≪⃒";
|
4993 | var nLtv = "≪̸";
|
4994 | var nRightarrow = "⇏";
|
4995 | var nVDash = "⊯";
|
4996 | var nVdash = "⊮";
|
4997 | var nabla = "∇";
|
4998 | var nacute = "ń";
|
4999 | var nang = "∠⃒";
|
5000 | var nap = "≉";
|
5001 | var napE = "⩰̸";
|
5002 | var napid = "≋̸";
|
5003 | var napos = "ʼn";
|
5004 | var napprox = "≉";
|
5005 | var natur = "♮";
|
5006 | var natural = "♮";
|
5007 | var naturals = "ℕ";
|
5008 | var nbs = " ";
|
5009 | var nbsp = " ";
|
5010 | var nbump = "≎̸";
|
5011 | var nbumpe = "≏̸";
|
5012 | var ncap = "⩃";
|
5013 | var ncaron = "ň";
|
5014 | var ncedil = "ņ";
|
5015 | var ncong = "≇";
|
5016 | var ncongdot = "⩭̸";
|
5017 | var ncup = "⩂";
|
5018 | var ncy = "н";
|
5019 | var ndash = "–";
|
5020 | var ne = "≠";
|
5021 | var neArr = "⇗";
|
5022 | var nearhk = "⤤";
|
5023 | var nearr = "↗";
|
5024 | var nearrow = "↗";
|
5025 | var nedot = "≐̸";
|
5026 | var nequiv = "≢";
|
5027 | var nesear = "⤨";
|
5028 | var nesim = "≂̸";
|
5029 | var nexist = "∄";
|
5030 | var nexists = "∄";
|
5031 | var nfr = "𝔫";
|
5032 | var ngE = "≧̸";
|
5033 | var nge = "≱";
|
5034 | var ngeq = "≱";
|
5035 | var ngeqq = "≧̸";
|
5036 | var ngeqslant = "⩾̸";
|
5037 | var nges = "⩾̸";
|
5038 | var ngsim = "≵";
|
5039 | var ngt = "≯";
|
5040 | var ngtr = "≯";
|
5041 | var nhArr = "⇎";
|
5042 | var nharr = "↮";
|
5043 | var nhpar = "⫲";
|
5044 | var ni = "∋";
|
5045 | var nis = "⋼";
|
5046 | var nisd = "⋺";
|
5047 | var niv = "∋";
|
5048 | var njcy = "њ";
|
5049 | var nlArr = "⇍";
|
5050 | var nlE = "≦̸";
|
5051 | var nlarr = "↚";
|
5052 | var nldr = "‥";
|
5053 | var nle = "≰";
|
5054 | var nleftarrow = "↚";
|
5055 | var nleftrightarrow = "↮";
|
5056 | var nleq = "≰";
|
5057 | var nleqq = "≦̸";
|
5058 | var nleqslant = "⩽̸";
|
5059 | var nles = "⩽̸";
|
5060 | var nless = "≮";
|
5061 | var nlsim = "≴";
|
5062 | var nlt = "≮";
|
5063 | var nltri = "⋪";
|
5064 | var nltrie = "⋬";
|
5065 | var nmid = "∤";
|
5066 | var nopf = "𝕟";
|
5067 | var no = "¬";
|
5068 | var not = "¬";
|
5069 | var notin = "∉";
|
5070 | var notinE = "⋹̸";
|
5071 | var notindot = "⋵̸";
|
5072 | var notinva = "∉";
|
5073 | var notinvb = "⋷";
|
5074 | var notinvc = "⋶";
|
5075 | var notni = "∌";
|
5076 | var notniva = "∌";
|
5077 | var notnivb = "⋾";
|
5078 | var notnivc = "⋽";
|
5079 | var npar = "∦";
|
5080 | var nparallel = "∦";
|
5081 | var nparsl = "⫽⃥";
|
5082 | var npart = "∂̸";
|
5083 | var npolint = "⨔";
|
5084 | var npr = "⊀";
|
5085 | var nprcue = "⋠";
|
5086 | var npre = "⪯̸";
|
5087 | var nprec = "⊀";
|
5088 | var npreceq = "⪯̸";
|
5089 | var nrArr = "⇏";
|
5090 | var nrarr = "↛";
|
5091 | var nrarrc = "⤳̸";
|
5092 | var nrarrw = "↝̸";
|
5093 | var nrightarrow = "↛";
|
5094 | var nrtri = "⋫";
|
5095 | var nrtrie = "⋭";
|
5096 | var nsc = "⊁";
|
5097 | var nsccue = "⋡";
|
5098 | var nsce = "⪰̸";
|
5099 | var nscr = "𝓃";
|
5100 | var nshortmid = "∤";
|
5101 | var nshortparallel = "∦";
|
5102 | var nsim = "≁";
|
5103 | var nsime = "≄";
|
5104 | var nsimeq = "≄";
|
5105 | var nsmid = "∤";
|
5106 | var nspar = "∦";
|
5107 | var nsqsube = "⋢";
|
5108 | var nsqsupe = "⋣";
|
5109 | var nsub = "⊄";
|
5110 | var nsubE = "⫅̸";
|
5111 | var nsube = "⊈";
|
5112 | var nsubset = "⊂⃒";
|
5113 | var nsubseteq = "⊈";
|
5114 | var nsubseteqq = "⫅̸";
|
5115 | var nsucc = "⊁";
|
5116 | var nsucceq = "⪰̸";
|
5117 | var nsup = "⊅";
|
5118 | var nsupE = "⫆̸";
|
5119 | var nsupe = "⊉";
|
5120 | var nsupset = "⊃⃒";
|
5121 | var nsupseteq = "⊉";
|
5122 | var nsupseteqq = "⫆̸";
|
5123 | var ntgl = "≹";
|
5124 | var ntild = "ñ";
|
5125 | var ntilde = "ñ";
|
5126 | var ntlg = "≸";
|
5127 | var ntriangleleft = "⋪";
|
5128 | var ntrianglelefteq = "⋬";
|
5129 | var ntriangleright = "⋫";
|
5130 | var ntrianglerighteq = "⋭";
|
5131 | var nu = "ν";
|
5132 | var num = "#";
|
5133 | var numero = "№";
|
5134 | var numsp = " ";
|
5135 | var nvDash = "⊭";
|
5136 | var nvHarr = "⤄";
|
5137 | var nvap = "≍⃒";
|
5138 | var nvdash = "⊬";
|
5139 | var nvge = "≥⃒";
|
5140 | var nvgt = ">⃒";
|
5141 | var nvinfin = "⧞";
|
5142 | var nvlArr = "⤂";
|
5143 | var nvle = "≤⃒";
|
5144 | var nvlt = "<⃒";
|
5145 | var nvltrie = "⊴⃒";
|
5146 | var nvrArr = "⤃";
|
5147 | var nvrtrie = "⊵⃒";
|
5148 | var nvsim = "∼⃒";
|
5149 | var nwArr = "⇖";
|
5150 | var nwarhk = "⤣";
|
5151 | var nwarr = "↖";
|
5152 | var nwarrow = "↖";
|
5153 | var nwnear = "⤧";
|
5154 | var oS = "Ⓢ";
|
5155 | var oacut = "ó";
|
5156 | var oacute = "ó";
|
5157 | var oast = "⊛";
|
5158 | var ocir = "ô";
|
5159 | var ocirc = "ô";
|
5160 | var ocy = "о";
|
5161 | var odash = "⊝";
|
5162 | var odblac = "ő";
|
5163 | var odiv = "⨸";
|
5164 | var odot = "⊙";
|
5165 | var odsold = "⦼";
|
5166 | var oelig = "œ";
|
5167 | var ofcir = "⦿";
|
5168 | var ofr = "𝔬";
|
5169 | var ogon = "˛";
|
5170 | var ograv = "ò";
|
5171 | var ograve = "ò";
|
5172 | var ogt = "⧁";
|
5173 | var ohbar = "⦵";
|
5174 | var ohm = "Ω";
|
5175 | var oint = "∮";
|
5176 | var olarr = "↺";
|
5177 | var olcir = "⦾";
|
5178 | var olcross = "⦻";
|
5179 | var oline = "‾";
|
5180 | var olt = "⧀";
|
5181 | var omacr = "ō";
|
5182 | var omega = "ω";
|
5183 | var omicron = "ο";
|
5184 | var omid = "⦶";
|
5185 | var ominus = "⊖";
|
5186 | var oopf = "𝕠";
|
5187 | var opar = "⦷";
|
5188 | var operp = "⦹";
|
5189 | var oplus = "⊕";
|
5190 | var or = "∨";
|
5191 | var orarr = "↻";
|
5192 | var ord = "º";
|
5193 | var order = "ℴ";
|
5194 | var orderof = "ℴ";
|
5195 | var ordf = "ª";
|
5196 | var ordm = "º";
|
5197 | var origof = "⊶";
|
5198 | var oror = "⩖";
|
5199 | var orslope = "⩗";
|
5200 | var orv = "⩛";
|
5201 | var oscr = "ℴ";
|
5202 | var oslas = "ø";
|
5203 | var oslash = "ø";
|
5204 | var osol = "⊘";
|
5205 | var otild = "õ";
|
5206 | var otilde = "õ";
|
5207 | var otimes = "⊗";
|
5208 | var otimesas = "⨶";
|
5209 | var oum = "ö";
|
5210 | var ouml = "ö";
|
5211 | var ovbar = "⌽";
|
5212 | var par = "¶";
|
5213 | var para = "¶";
|
5214 | var parallel = "∥";
|
5215 | var parsim = "⫳";
|
5216 | var parsl = "⫽";
|
5217 | var part = "∂";
|
5218 | var pcy = "п";
|
5219 | var percnt = "%";
|
5220 | var period = ".";
|
5221 | var permil = "‰";
|
5222 | var perp = "⊥";
|
5223 | var pertenk = "‱";
|
5224 | var pfr = "𝔭";
|
5225 | var phi = "φ";
|
5226 | var phiv = "ϕ";
|
5227 | var phmmat = "ℳ";
|
5228 | var phone = "☎";
|
5229 | var pi = "π";
|
5230 | var pitchfork = "⋔";
|
5231 | var piv = "ϖ";
|
5232 | var planck = "ℏ";
|
5233 | var planckh = "ℎ";
|
5234 | var plankv = "ℏ";
|
5235 | var plus = "+";
|
5236 | var plusacir = "⨣";
|
5237 | var plusb = "⊞";
|
5238 | var pluscir = "⨢";
|
5239 | var plusdo = "∔";
|
5240 | var plusdu = "⨥";
|
5241 | var pluse = "⩲";
|
5242 | var plusm = "±";
|
5243 | var plusmn = "±";
|
5244 | var plussim = "⨦";
|
5245 | var plustwo = "⨧";
|
5246 | var pm = "±";
|
5247 | var pointint = "⨕";
|
5248 | var popf = "𝕡";
|
5249 | var poun = "£";
|
5250 | var pound = "£";
|
5251 | var pr = "≺";
|
5252 | var prE = "⪳";
|
5253 | var prap = "⪷";
|
5254 | var prcue = "≼";
|
5255 | var pre = "⪯";
|
5256 | var prec = "≺";
|
5257 | var precapprox = "⪷";
|
5258 | var preccurlyeq = "≼";
|
5259 | var preceq = "⪯";
|
5260 | var precnapprox = "⪹";
|
5261 | var precneqq = "⪵";
|
5262 | var precnsim = "⋨";
|
5263 | var precsim = "≾";
|
5264 | var prime = "′";
|
5265 | var primes = "ℙ";
|
5266 | var prnE = "⪵";
|
5267 | var prnap = "⪹";
|
5268 | var prnsim = "⋨";
|
5269 | var prod = "∏";
|
5270 | var profalar = "⌮";
|
5271 | var profline = "⌒";
|
5272 | var profsurf = "⌓";
|
5273 | var prop = "∝";
|
5274 | var propto = "∝";
|
5275 | var prsim = "≾";
|
5276 | var prurel = "⊰";
|
5277 | var pscr = "𝓅";
|
5278 | var psi = "ψ";
|
5279 | var puncsp = " ";
|
5280 | var qfr = "𝔮";
|
5281 | var qint = "⨌";
|
5282 | var qopf = "𝕢";
|
5283 | var qprime = "⁗";
|
5284 | var qscr = "𝓆";
|
5285 | var quaternions = "ℍ";
|
5286 | var quatint = "⨖";
|
5287 | var quest = "?";
|
5288 | var questeq = "≟";
|
5289 | var quo = "\"";
|
5290 | var quot = "\"";
|
5291 | var rAarr = "⇛";
|
5292 | var rArr = "⇒";
|
5293 | var rAtail = "⤜";
|
5294 | var rBarr = "⤏";
|
5295 | var rHar = "⥤";
|
5296 | var race = "∽̱";
|
5297 | var racute = "ŕ";
|
5298 | var radic = "√";
|
5299 | var raemptyv = "⦳";
|
5300 | var rang = "⟩";
|
5301 | var rangd = "⦒";
|
5302 | var range = "⦥";
|
5303 | var rangle = "⟩";
|
5304 | var raqu = "»";
|
5305 | var raquo = "»";
|
5306 | var rarr = "→";
|
5307 | var rarrap = "⥵";
|
5308 | var rarrb = "⇥";
|
5309 | var rarrbfs = "⤠";
|
5310 | var rarrc = "⤳";
|
5311 | var rarrfs = "⤞";
|
5312 | var rarrhk = "↪";
|
5313 | var rarrlp = "↬";
|
5314 | var rarrpl = "⥅";
|
5315 | var rarrsim = "⥴";
|
5316 | var rarrtl = "↣";
|
5317 | var rarrw = "↝";
|
5318 | var ratail = "⤚";
|
5319 | var ratio = "∶";
|
5320 | var rationals = "ℚ";
|
5321 | var rbarr = "⤍";
|
5322 | var rbbrk = "❳";
|
5323 | var rbrace = "}";
|
5324 | var rbrack = "]";
|
5325 | var rbrke = "⦌";
|
5326 | var rbrksld = "⦎";
|
5327 | var rbrkslu = "⦐";
|
5328 | var rcaron = "ř";
|
5329 | var rcedil = "ŗ";
|
5330 | var rceil = "⌉";
|
5331 | var rcub = "}";
|
5332 | var rcy = "р";
|
5333 | var rdca = "⤷";
|
5334 | var rdldhar = "⥩";
|
5335 | var rdquo = "”";
|
5336 | var rdquor = "”";
|
5337 | var rdsh = "↳";
|
5338 | var real = "ℜ";
|
5339 | var realine = "ℛ";
|
5340 | var realpart = "ℜ";
|
5341 | var reals = "ℝ";
|
5342 | var rect = "▭";
|
5343 | var re = "®";
|
5344 | var reg = "®";
|
5345 | var rfisht = "⥽";
|
5346 | var rfloor = "⌋";
|
5347 | var rfr = "𝔯";
|
5348 | var rhard = "⇁";
|
5349 | var rharu = "⇀";
|
5350 | var rharul = "⥬";
|
5351 | var rho = "ρ";
|
5352 | var rhov = "ϱ";
|
5353 | var rightarrow = "→";
|
5354 | var rightarrowtail = "↣";
|
5355 | var rightharpoondown = "⇁";
|
5356 | var rightharpoonup = "⇀";
|
5357 | var rightleftarrows = "⇄";
|
5358 | var rightleftharpoons = "⇌";
|
5359 | var rightrightarrows = "⇉";
|
5360 | var rightsquigarrow = "↝";
|
5361 | var rightthreetimes = "⋌";
|
5362 | var ring = "˚";
|
5363 | var risingdotseq = "≓";
|
5364 | var rlarr = "⇄";
|
5365 | var rlhar = "⇌";
|
5366 | var rlm = "";
|
5367 | var rmoust = "⎱";
|
5368 | var rmoustache = "⎱";
|
5369 | var rnmid = "⫮";
|
5370 | var roang = "⟭";
|
5371 | var roarr = "⇾";
|
5372 | var robrk = "⟧";
|
5373 | var ropar = "⦆";
|
5374 | var ropf = "𝕣";
|
5375 | var roplus = "⨮";
|
5376 | var rotimes = "⨵";
|
5377 | var rpar = ")";
|
5378 | var rpargt = "⦔";
|
5379 | var rppolint = "⨒";
|
5380 | var rrarr = "⇉";
|
5381 | var rsaquo = "›";
|
5382 | var rscr = "𝓇";
|
5383 | var rsh = "↱";
|
5384 | var rsqb = "]";
|
5385 | var rsquo = "’";
|
5386 | var rsquor = "’";
|
5387 | var rthree = "⋌";
|
5388 | var rtimes = "⋊";
|
5389 | var rtri = "▹";
|
5390 | var rtrie = "⊵";
|
5391 | var rtrif = "▸";
|
5392 | var rtriltri = "⧎";
|
5393 | var ruluhar = "⥨";
|
5394 | var rx = "℞";
|
5395 | var sacute = "ś";
|
5396 | var sbquo = "‚";
|
5397 | var sc = "≻";
|
5398 | var scE = "⪴";
|
5399 | var scap = "⪸";
|
5400 | var scaron = "š";
|
5401 | var sccue = "≽";
|
5402 | var sce = "⪰";
|
5403 | var scedil = "ş";
|
5404 | var scirc = "ŝ";
|
5405 | var scnE = "⪶";
|
5406 | var scnap = "⪺";
|
5407 | var scnsim = "⋩";
|
5408 | var scpolint = "⨓";
|
5409 | var scsim = "≿";
|
5410 | var scy = "с";
|
5411 | var sdot = "⋅";
|
5412 | var sdotb = "⊡";
|
5413 | var sdote = "⩦";
|
5414 | var seArr = "⇘";
|
5415 | var searhk = "⤥";
|
5416 | var searr = "↘";
|
5417 | var searrow = "↘";
|
5418 | var sec = "§";
|
5419 | var sect = "§";
|
5420 | var semi = ";";
|
5421 | var seswar = "⤩";
|
5422 | var setminus = "∖";
|
5423 | var setmn = "∖";
|
5424 | var sext = "✶";
|
5425 | var sfr = "𝔰";
|
5426 | var sfrown = "⌢";
|
5427 | var sharp = "♯";
|
5428 | var shchcy = "щ";
|
5429 | var shcy = "ш";
|
5430 | var shortmid = "∣";
|
5431 | var shortparallel = "∥";
|
5432 | var sh = "";
|
5433 | var shy = "";
|
5434 | var sigma = "σ";
|
5435 | var sigmaf = "ς";
|
5436 | var sigmav = "ς";
|
5437 | var sim = "∼";
|
5438 | var simdot = "⩪";
|
5439 | var sime = "≃";
|
5440 | var simeq = "≃";
|
5441 | var simg = "⪞";
|
5442 | var simgE = "⪠";
|
5443 | var siml = "⪝";
|
5444 | var simlE = "⪟";
|
5445 | var simne = "≆";
|
5446 | var simplus = "⨤";
|
5447 | var simrarr = "⥲";
|
5448 | var slarr = "←";
|
5449 | var smallsetminus = "∖";
|
5450 | var smashp = "⨳";
|
5451 | var smeparsl = "⧤";
|
5452 | var smid = "∣";
|
5453 | var smile = "⌣";
|
5454 | var smt = "⪪";
|
5455 | var smte = "⪬";
|
5456 | var smtes = "⪬︀";
|
5457 | var softcy = "ь";
|
5458 | var sol = "/";
|
5459 | var solb = "⧄";
|
5460 | var solbar = "⌿";
|
5461 | var sopf = "𝕤";
|
5462 | var spades = "♠";
|
5463 | var spadesuit = "♠";
|
5464 | var spar = "∥";
|
5465 | var sqcap = "⊓";
|
5466 | var sqcaps = "⊓︀";
|
5467 | var sqcup = "⊔";
|
5468 | var sqcups = "⊔︀";
|
5469 | var sqsub = "⊏";
|
5470 | var sqsube = "⊑";
|
5471 | var sqsubset = "⊏";
|
5472 | var sqsubseteq = "⊑";
|
5473 | var sqsup = "⊐";
|
5474 | var sqsupe = "⊒";
|
5475 | var sqsupset = "⊐";
|
5476 | var sqsupseteq = "⊒";
|
5477 | var squ = "□";
|
5478 | var square = "□";
|
5479 | var squarf = "▪";
|
5480 | var squf = "▪";
|
5481 | var srarr = "→";
|
5482 | var sscr = "𝓈";
|
5483 | var ssetmn = "∖";
|
5484 | var ssmile = "⌣";
|
5485 | var sstarf = "⋆";
|
5486 | var star = "☆";
|
5487 | var starf = "★";
|
5488 | var straightepsilon = "ϵ";
|
5489 | var straightphi = "ϕ";
|
5490 | var strns = "¯";
|
5491 | var sub = "⊂";
|
5492 | var subE = "⫅";
|
5493 | var subdot = "⪽";
|
5494 | var sube = "⊆";
|
5495 | var subedot = "⫃";
|
5496 | var submult = "⫁";
|
5497 | var subnE = "⫋";
|
5498 | var subne = "⊊";
|
5499 | var subplus = "⪿";
|
5500 | var subrarr = "⥹";
|
5501 | var subset = "⊂";
|
5502 | var subseteq = "⊆";
|
5503 | var subseteqq = "⫅";
|
5504 | var subsetneq = "⊊";
|
5505 | var subsetneqq = "⫋";
|
5506 | var subsim = "⫇";
|
5507 | var subsub = "⫕";
|
5508 | var subsup = "⫓";
|
5509 | var succ = "≻";
|
5510 | var succapprox = "⪸";
|
5511 | var succcurlyeq = "≽";
|
5512 | var succeq = "⪰";
|
5513 | var succnapprox = "⪺";
|
5514 | var succneqq = "⪶";
|
5515 | var succnsim = "⋩";
|
5516 | var succsim = "≿";
|
5517 | var sum = "∑";
|
5518 | var sung = "♪";
|
5519 | var sup = "⊃";
|
5520 | var sup1 = "¹";
|
5521 | var sup2 = "²";
|
5522 | var sup3 = "³";
|
5523 | var supE = "⫆";
|
5524 | var supdot = "⪾";
|
5525 | var supdsub = "⫘";
|
5526 | var supe = "⊇";
|
5527 | var supedot = "⫄";
|
5528 | var suphsol = "⟉";
|
5529 | var suphsub = "⫗";
|
5530 | var suplarr = "⥻";
|
5531 | var supmult = "⫂";
|
5532 | var supnE = "⫌";
|
5533 | var supne = "⊋";
|
5534 | var supplus = "⫀";
|
5535 | var supset = "⊃";
|
5536 | var supseteq = "⊇";
|
5537 | var supseteqq = "⫆";
|
5538 | var supsetneq = "⊋";
|
5539 | var supsetneqq = "⫌";
|
5540 | var supsim = "⫈";
|
5541 | var supsub = "⫔";
|
5542 | var supsup = "⫖";
|
5543 | var swArr = "⇙";
|
5544 | var swarhk = "⤦";
|
5545 | var swarr = "↙";
|
5546 | var swarrow = "↙";
|
5547 | var swnwar = "⤪";
|
5548 | var szli = "ß";
|
5549 | var szlig = "ß";
|
5550 | var target = "⌖";
|
5551 | var tau = "τ";
|
5552 | var tbrk = "⎴";
|
5553 | var tcaron = "ť";
|
5554 | var tcedil = "ţ";
|
5555 | var tcy = "т";
|
5556 | var tdot = "⃛";
|
5557 | var telrec = "⌕";
|
5558 | var tfr = "𝔱";
|
5559 | var there4 = "∴";
|
5560 | var therefore = "∴";
|
5561 | var theta = "θ";
|
5562 | var thetasym = "ϑ";
|
5563 | var thetav = "ϑ";
|
5564 | var thickapprox = "≈";
|
5565 | var thicksim = "∼";
|
5566 | var thinsp = " ";
|
5567 | var thkap = "≈";
|
5568 | var thksim = "∼";
|
5569 | var thor = "þ";
|
5570 | var thorn = "þ";
|
5571 | var tilde = "˜";
|
5572 | var time = "×";
|
5573 | var times = "×";
|
5574 | var timesb = "⊠";
|
5575 | var timesbar = "⨱";
|
5576 | var timesd = "⨰";
|
5577 | var tint = "∭";
|
5578 | var toea = "⤨";
|
5579 | var top = "⊤";
|
5580 | var topbot = "⌶";
|
5581 | var topcir = "⫱";
|
5582 | var topf = "𝕥";
|
5583 | var topfork = "⫚";
|
5584 | var tosa = "⤩";
|
5585 | var tprime = "‴";
|
5586 | var trade = "™";
|
5587 | var triangle = "▵";
|
5588 | var triangledown = "▿";
|
5589 | var triangleleft = "◃";
|
5590 | var trianglelefteq = "⊴";
|
5591 | var triangleq = "≜";
|
5592 | var triangleright = "▹";
|
5593 | var trianglerighteq = "⊵";
|
5594 | var tridot = "◬";
|
5595 | var trie = "≜";
|
5596 | var triminus = "⨺";
|
5597 | var triplus = "⨹";
|
5598 | var trisb = "⧍";
|
5599 | var tritime = "⨻";
|
5600 | var trpezium = "⏢";
|
5601 | var tscr = "𝓉";
|
5602 | var tscy = "ц";
|
5603 | var tshcy = "ћ";
|
5604 | var tstrok = "ŧ";
|
5605 | var twixt = "≬";
|
5606 | var twoheadleftarrow = "↞";
|
5607 | var twoheadrightarrow = "↠";
|
5608 | var uArr = "⇑";
|
5609 | var uHar = "⥣";
|
5610 | var uacut = "ú";
|
5611 | var uacute = "ú";
|
5612 | var uarr = "↑";
|
5613 | var ubrcy = "ў";
|
5614 | var ubreve = "ŭ";
|
5615 | var ucir = "û";
|
5616 | var ucirc = "û";
|
5617 | var ucy = "у";
|
5618 | var udarr = "⇅";
|
5619 | var udblac = "ű";
|
5620 | var udhar = "⥮";
|
5621 | var ufisht = "⥾";
|
5622 | var ufr = "𝔲";
|
5623 | var ugrav = "ù";
|
5624 | var ugrave = "ù";
|
5625 | var uharl = "↿";
|
5626 | var uharr = "↾";
|
5627 | var uhblk = "▀";
|
5628 | var ulcorn = "⌜";
|
5629 | var ulcorner = "⌜";
|
5630 | var ulcrop = "⌏";
|
5631 | var ultri = "◸";
|
5632 | var umacr = "ū";
|
5633 | var um = "¨";
|
5634 | var uml = "¨";
|
5635 | var uogon = "ų";
|
5636 | var uopf = "𝕦";
|
5637 | var uparrow = "↑";
|
5638 | var updownarrow = "↕";
|
5639 | var upharpoonleft = "↿";
|
5640 | var upharpoonright = "↾";
|
5641 | var uplus = "⊎";
|
5642 | var upsi = "υ";
|
5643 | var upsih = "ϒ";
|
5644 | var upsilon = "υ";
|
5645 | var upuparrows = "⇈";
|
5646 | var urcorn = "⌝";
|
5647 | var urcorner = "⌝";
|
5648 | var urcrop = "⌎";
|
5649 | var uring = "ů";
|
5650 | var urtri = "◹";
|
5651 | var uscr = "𝓊";
|
5652 | var utdot = "⋰";
|
5653 | var utilde = "ũ";
|
5654 | var utri = "▵";
|
5655 | var utrif = "▴";
|
5656 | var uuarr = "⇈";
|
5657 | var uum = "ü";
|
5658 | var uuml = "ü";
|
5659 | var uwangle = "⦧";
|
5660 | var vArr = "⇕";
|
5661 | var vBar = "⫨";
|
5662 | var vBarv = "⫩";
|
5663 | var vDash = "⊨";
|
5664 | var vangrt = "⦜";
|
5665 | var varepsilon = "ϵ";
|
5666 | var varkappa = "ϰ";
|
5667 | var varnothing = "∅";
|
5668 | var varphi = "ϕ";
|
5669 | var varpi = "ϖ";
|
5670 | var varpropto = "∝";
|
5671 | var varr = "↕";
|
5672 | var varrho = "ϱ";
|
5673 | var varsigma = "ς";
|
5674 | var varsubsetneq = "⊊︀";
|
5675 | var varsubsetneqq = "⫋︀";
|
5676 | var varsupsetneq = "⊋︀";
|
5677 | var varsupsetneqq = "⫌︀";
|
5678 | var vartheta = "ϑ";
|
5679 | var vartriangleleft = "⊲";
|
5680 | var vartriangleright = "⊳";
|
5681 | var vcy = "в";
|
5682 | var vdash = "⊢";
|
5683 | var vee = "∨";
|
5684 | var veebar = "⊻";
|
5685 | var veeeq = "≚";
|
5686 | var vellip = "⋮";
|
5687 | var verbar = "|";
|
5688 | var vert = "|";
|
5689 | var vfr = "𝔳";
|
5690 | var vltri = "⊲";
|
5691 | var vnsub = "⊂⃒";
|
5692 | var vnsup = "⊃⃒";
|
5693 | var vopf = "𝕧";
|
5694 | var vprop = "∝";
|
5695 | var vrtri = "⊳";
|
5696 | var vscr = "𝓋";
|
5697 | var vsubnE = "⫋︀";
|
5698 | var vsubne = "⊊︀";
|
5699 | var vsupnE = "⫌︀";
|
5700 | var vsupne = "⊋︀";
|
5701 | var vzigzag = "⦚";
|
5702 | var wcirc = "ŵ";
|
5703 | var wedbar = "⩟";
|
5704 | var wedge = "∧";
|
5705 | var wedgeq = "≙";
|
5706 | var weierp = "℘";
|
5707 | var wfr = "𝔴";
|
5708 | var wopf = "𝕨";
|
5709 | var wp = "℘";
|
5710 | var wr = "≀";
|
5711 | var wreath = "≀";
|
5712 | var wscr = "𝓌";
|
5713 | var xcap = "⋂";
|
5714 | var xcirc = "◯";
|
5715 | var xcup = "⋃";
|
5716 | var xdtri = "▽";
|
5717 | var xfr = "𝔵";
|
5718 | var xhArr = "⟺";
|
5719 | var xharr = "⟷";
|
5720 | var xi = "ξ";
|
5721 | var xlArr = "⟸";
|
5722 | var xlarr = "⟵";
|
5723 | var xmap = "⟼";
|
5724 | var xnis = "⋻";
|
5725 | var xodot = "⨀";
|
5726 | var xopf = "𝕩";
|
5727 | var xoplus = "⨁";
|
5728 | var xotime = "⨂";
|
5729 | var xrArr = "⟹";
|
5730 | var xrarr = "⟶";
|
5731 | var xscr = "𝓍";
|
5732 | var xsqcup = "⨆";
|
5733 | var xuplus = "⨄";
|
5734 | var xutri = "△";
|
5735 | var xvee = "⋁";
|
5736 | var xwedge = "⋀";
|
5737 | var yacut = "ý";
|
5738 | var yacute = "ý";
|
5739 | var yacy = "я";
|
5740 | var ycirc = "ŷ";
|
5741 | var ycy = "ы";
|
5742 | var ye = "¥";
|
5743 | var yen = "¥";
|
5744 | var yfr = "𝔶";
|
5745 | var yicy = "ї";
|
5746 | var yopf = "𝕪";
|
5747 | var yscr = "𝓎";
|
5748 | var yucy = "ю";
|
5749 | var yum = "ÿ";
|
5750 | var yuml = "ÿ";
|
5751 | var zacute = "ź";
|
5752 | var zcaron = "ž";
|
5753 | var zcy = "з";
|
5754 | var zdot = "ż";
|
5755 | var zeetrf = "ℨ";
|
5756 | var zeta = "ζ";
|
5757 | var zfr = "𝔷";
|
5758 | var zhcy = "ж";
|
5759 | var zigrarr = "⇝";
|
5760 | var zopf = "𝕫";
|
5761 | var zscr = "𝓏";
|
5762 | var zwj = "";
|
5763 | var zwnj = "";
|
5764 | var require$$0 = {
|
5765 | AEli: AEli,
|
5766 | AElig: AElig,
|
5767 | AM: AM,
|
5768 | AMP: AMP,
|
5769 | Aacut: Aacut,
|
5770 | Aacute: Aacute,
|
5771 | Abreve: Abreve,
|
5772 | Acir: Acir,
|
5773 | Acirc: Acirc,
|
5774 | Acy: Acy,
|
5775 | Afr: Afr,
|
5776 | Agrav: Agrav,
|
5777 | Agrave: Agrave,
|
5778 | Alpha: Alpha,
|
5779 | Amacr: Amacr,
|
5780 | And: And,
|
5781 | Aogon: Aogon,
|
5782 | Aopf: Aopf,
|
5783 | ApplyFunction: ApplyFunction,
|
5784 | Arin: Arin,
|
5785 | Aring: Aring,
|
5786 | Ascr: Ascr,
|
5787 | Assign: Assign,
|
5788 | Atild: Atild,
|
5789 | Atilde: Atilde,
|
5790 | Aum: Aum,
|
5791 | Auml: Auml,
|
5792 | Backslash: Backslash,
|
5793 | Barv: Barv,
|
5794 | Barwed: Barwed,
|
5795 | Bcy: Bcy,
|
5796 | Because: Because,
|
5797 | Bernoullis: Bernoullis,
|
5798 | Beta: Beta,
|
5799 | Bfr: Bfr,
|
5800 | Bopf: Bopf,
|
5801 | Breve: Breve,
|
5802 | Bscr: Bscr,
|
5803 | Bumpeq: Bumpeq,
|
5804 | CHcy: CHcy,
|
5805 | COP: COP,
|
5806 | COPY: COPY,
|
5807 | Cacute: Cacute,
|
5808 | Cap: Cap,
|
5809 | CapitalDifferentialD: CapitalDifferentialD,
|
5810 | Cayleys: Cayleys,
|
5811 | Ccaron: Ccaron,
|
5812 | Ccedi: Ccedi,
|
5813 | Ccedil: Ccedil,
|
5814 | Ccirc: Ccirc,
|
5815 | Cconint: Cconint,
|
5816 | Cdot: Cdot,
|
5817 | Cedilla: Cedilla,
|
5818 | CenterDot: CenterDot,
|
5819 | Cfr: Cfr,
|
5820 | Chi: Chi,
|
5821 | CircleDot: CircleDot,
|
5822 | CircleMinus: CircleMinus,
|
5823 | CirclePlus: CirclePlus,
|
5824 | CircleTimes: CircleTimes,
|
5825 | ClockwiseContourIntegral: ClockwiseContourIntegral,
|
5826 | CloseCurlyDoubleQuote: CloseCurlyDoubleQuote,
|
5827 | CloseCurlyQuote: CloseCurlyQuote,
|
5828 | Colon: Colon,
|
5829 | Colone: Colone,
|
5830 | Congruent: Congruent,
|
5831 | Conint: Conint,
|
5832 | ContourIntegral: ContourIntegral,
|
5833 | Copf: Copf,
|
5834 | Coproduct: Coproduct,
|
5835 | CounterClockwiseContourIntegral: CounterClockwiseContourIntegral,
|
5836 | Cross: Cross,
|
5837 | Cscr: Cscr,
|
5838 | Cup: Cup,
|
5839 | CupCap: CupCap,
|
5840 | DD: DD,
|
5841 | DDotrahd: DDotrahd,
|
5842 | DJcy: DJcy,
|
5843 | DScy: DScy,
|
5844 | DZcy: DZcy,
|
5845 | Dagger: Dagger,
|
5846 | Darr: Darr,
|
5847 | Dashv: Dashv,
|
5848 | Dcaron: Dcaron,
|
5849 | Dcy: Dcy,
|
5850 | Del: Del,
|
5851 | Delta: Delta,
|
5852 | Dfr: Dfr,
|
5853 | DiacriticalAcute: DiacriticalAcute,
|
5854 | DiacriticalDot: DiacriticalDot,
|
5855 | DiacriticalDoubleAcute: DiacriticalDoubleAcute,
|
5856 | DiacriticalGrave: DiacriticalGrave,
|
5857 | DiacriticalTilde: DiacriticalTilde,
|
5858 | Diamond: Diamond,
|
5859 | DifferentialD: DifferentialD,
|
5860 | Dopf: Dopf,
|
5861 | Dot: Dot,
|
5862 | DotDot: DotDot,
|
5863 | DotEqual: DotEqual,
|
5864 | DoubleContourIntegral: DoubleContourIntegral,
|
5865 | DoubleDot: DoubleDot,
|
5866 | DoubleDownArrow: DoubleDownArrow,
|
5867 | DoubleLeftArrow: DoubleLeftArrow,
|
5868 | DoubleLeftRightArrow: DoubleLeftRightArrow,
|
5869 | DoubleLeftTee: DoubleLeftTee,
|
5870 | DoubleLongLeftArrow: DoubleLongLeftArrow,
|
5871 | DoubleLongLeftRightArrow: DoubleLongLeftRightArrow,
|
5872 | DoubleLongRightArrow: DoubleLongRightArrow,
|
5873 | DoubleRightArrow: DoubleRightArrow,
|
5874 | DoubleRightTee: DoubleRightTee,
|
5875 | DoubleUpArrow: DoubleUpArrow,
|
5876 | DoubleUpDownArrow: DoubleUpDownArrow,
|
5877 | DoubleVerticalBar: DoubleVerticalBar,
|
5878 | DownArrow: DownArrow,
|
5879 | DownArrowBar: DownArrowBar,
|
5880 | DownArrowUpArrow: DownArrowUpArrow,
|
5881 | DownBreve: DownBreve,
|
5882 | DownLeftRightVector: DownLeftRightVector,
|
5883 | DownLeftTeeVector: DownLeftTeeVector,
|
5884 | DownLeftVector: DownLeftVector,
|
5885 | DownLeftVectorBar: DownLeftVectorBar,
|
5886 | DownRightTeeVector: DownRightTeeVector,
|
5887 | DownRightVector: DownRightVector,
|
5888 | DownRightVectorBar: DownRightVectorBar,
|
5889 | DownTee: DownTee,
|
5890 | DownTeeArrow: DownTeeArrow,
|
5891 | Downarrow: Downarrow,
|
5892 | Dscr: Dscr,
|
5893 | Dstrok: Dstrok,
|
5894 | ENG: ENG,
|
5895 | ET: ET,
|
5896 | ETH: ETH,
|
5897 | Eacut: Eacut,
|
5898 | Eacute: Eacute,
|
5899 | Ecaron: Ecaron,
|
5900 | Ecir: Ecir,
|
5901 | Ecirc: Ecirc,
|
5902 | Ecy: Ecy,
|
5903 | Edot: Edot,
|
5904 | Efr: Efr,
|
5905 | Egrav: Egrav,
|
5906 | Egrave: Egrave,
|
5907 | Element: Element,
|
5908 | Emacr: Emacr,
|
5909 | EmptySmallSquare: EmptySmallSquare,
|
5910 | EmptyVerySmallSquare: EmptyVerySmallSquare,
|
5911 | Eogon: Eogon,
|
5912 | Eopf: Eopf,
|
5913 | Epsilon: Epsilon,
|
5914 | Equal: Equal,
|
5915 | EqualTilde: EqualTilde,
|
5916 | Equilibrium: Equilibrium,
|
5917 | Escr: Escr,
|
5918 | Esim: Esim,
|
5919 | Eta: Eta,
|
5920 | Eum: Eum,
|
5921 | Euml: Euml,
|
5922 | Exists: Exists,
|
5923 | ExponentialE: ExponentialE,
|
5924 | Fcy: Fcy,
|
5925 | Ffr: Ffr,
|
5926 | FilledSmallSquare: FilledSmallSquare,
|
5927 | FilledVerySmallSquare: FilledVerySmallSquare,
|
5928 | Fopf: Fopf,
|
5929 | ForAll: ForAll,
|
5930 | Fouriertrf: Fouriertrf,
|
5931 | Fscr: Fscr,
|
5932 | GJcy: GJcy,
|
5933 | G: G,
|
5934 | GT: GT,
|
5935 | Gamma: Gamma,
|
5936 | Gammad: Gammad,
|
5937 | Gbreve: Gbreve,
|
5938 | Gcedil: Gcedil,
|
5939 | Gcirc: Gcirc,
|
5940 | Gcy: Gcy,
|
5941 | Gdot: Gdot,
|
5942 | Gfr: Gfr,
|
5943 | Gg: Gg,
|
5944 | Gopf: Gopf,
|
5945 | GreaterEqual: GreaterEqual,
|
5946 | GreaterEqualLess: GreaterEqualLess,
|
5947 | GreaterFullEqual: GreaterFullEqual,
|
5948 | GreaterGreater: GreaterGreater,
|
5949 | GreaterLess: GreaterLess,
|
5950 | GreaterSlantEqual: GreaterSlantEqual,
|
5951 | GreaterTilde: GreaterTilde,
|
5952 | Gscr: Gscr,
|
5953 | Gt: Gt,
|
5954 | HARDcy: HARDcy,
|
5955 | Hacek: Hacek,
|
5956 | Hat: Hat,
|
5957 | Hcirc: Hcirc,
|
5958 | Hfr: Hfr,
|
5959 | HilbertSpace: HilbertSpace,
|
5960 | Hopf: Hopf,
|
5961 | HorizontalLine: HorizontalLine,
|
5962 | Hscr: Hscr,
|
5963 | Hstrok: Hstrok,
|
5964 | HumpDownHump: HumpDownHump,
|
5965 | HumpEqual: HumpEqual,
|
5966 | IEcy: IEcy,
|
5967 | IJlig: IJlig,
|
5968 | IOcy: IOcy,
|
5969 | Iacut: Iacut,
|
5970 | Iacute: Iacute,
|
5971 | Icir: Icir,
|
5972 | Icirc: Icirc,
|
5973 | Icy: Icy,
|
5974 | Idot: Idot,
|
5975 | Ifr: Ifr,
|
5976 | Igrav: Igrav,
|
5977 | Igrave: Igrave,
|
5978 | Im: Im,
|
5979 | Imacr: Imacr,
|
5980 | ImaginaryI: ImaginaryI,
|
5981 | Implies: Implies,
|
5982 | Int: Int,
|
5983 | Integral: Integral,
|
5984 | Intersection: Intersection,
|
5985 | InvisibleComma: InvisibleComma,
|
5986 | InvisibleTimes: InvisibleTimes,
|
5987 | Iogon: Iogon,
|
5988 | Iopf: Iopf,
|
5989 | Iota: Iota,
|
5990 | Iscr: Iscr,
|
5991 | Itilde: Itilde,
|
5992 | Iukcy: Iukcy,
|
5993 | Ium: Ium,
|
5994 | Iuml: Iuml,
|
5995 | Jcirc: Jcirc,
|
5996 | Jcy: Jcy,
|
5997 | Jfr: Jfr,
|
5998 | Jopf: Jopf,
|
5999 | Jscr: Jscr,
|
6000 | Jsercy: Jsercy,
|
6001 | Jukcy: Jukcy,
|
6002 | KHcy: KHcy,
|
6003 | KJcy: KJcy,
|
6004 | Kappa: Kappa,
|
6005 | Kcedil: Kcedil,
|
6006 | Kcy: Kcy,
|
6007 | Kfr: Kfr,
|
6008 | Kopf: Kopf,
|
6009 | Kscr: Kscr,
|
6010 | LJcy: LJcy,
|
6011 | L: L,
|
6012 | LT: LT,
|
6013 | Lacute: Lacute,
|
6014 | Lambda: Lambda,
|
6015 | Lang: Lang,
|
6016 | Laplacetrf: Laplacetrf,
|
6017 | Larr: Larr,
|
6018 | Lcaron: Lcaron,
|
6019 | Lcedil: Lcedil,
|
6020 | Lcy: Lcy,
|
6021 | LeftAngleBracket: LeftAngleBracket,
|
6022 | LeftArrow: LeftArrow,
|
6023 | LeftArrowBar: LeftArrowBar,
|
6024 | LeftArrowRightArrow: LeftArrowRightArrow,
|
6025 | LeftCeiling: LeftCeiling,
|
6026 | LeftDoubleBracket: LeftDoubleBracket,
|
6027 | LeftDownTeeVector: LeftDownTeeVector,
|
6028 | LeftDownVector: LeftDownVector,
|
6029 | LeftDownVectorBar: LeftDownVectorBar,
|
6030 | LeftFloor: LeftFloor,
|
6031 | LeftRightArrow: LeftRightArrow,
|
6032 | LeftRightVector: LeftRightVector,
|
6033 | LeftTee: LeftTee,
|
6034 | LeftTeeArrow: LeftTeeArrow,
|
6035 | LeftTeeVector: LeftTeeVector,
|
6036 | LeftTriangle: LeftTriangle,
|
6037 | LeftTriangleBar: LeftTriangleBar,
|
6038 | LeftTriangleEqual: LeftTriangleEqual,
|
6039 | LeftUpDownVector: LeftUpDownVector,
|
6040 | LeftUpTeeVector: LeftUpTeeVector,
|
6041 | LeftUpVector: LeftUpVector,
|
6042 | LeftUpVectorBar: LeftUpVectorBar,
|
6043 | LeftVector: LeftVector,
|
6044 | LeftVectorBar: LeftVectorBar,
|
6045 | Leftarrow: Leftarrow,
|
6046 | Leftrightarrow: Leftrightarrow,
|
6047 | LessEqualGreater: LessEqualGreater,
|
6048 | LessFullEqual: LessFullEqual,
|
6049 | LessGreater: LessGreater,
|
6050 | LessLess: LessLess,
|
6051 | LessSlantEqual: LessSlantEqual,
|
6052 | LessTilde: LessTilde,
|
6053 | Lfr: Lfr,
|
6054 | Ll: Ll,
|
6055 | Lleftarrow: Lleftarrow,
|
6056 | Lmidot: Lmidot,
|
6057 | LongLeftArrow: LongLeftArrow,
|
6058 | LongLeftRightArrow: LongLeftRightArrow,
|
6059 | LongRightArrow: LongRightArrow,
|
6060 | Longleftarrow: Longleftarrow,
|
6061 | Longleftrightarrow: Longleftrightarrow,
|
6062 | Longrightarrow: Longrightarrow,
|
6063 | Lopf: Lopf,
|
6064 | LowerLeftArrow: LowerLeftArrow,
|
6065 | LowerRightArrow: LowerRightArrow,
|
6066 | Lscr: Lscr,
|
6067 | Lsh: Lsh,
|
6068 | Lstrok: Lstrok,
|
6069 | Lt: Lt,
|
6070 | "Map": "⤅",
|
6071 | Mcy: Mcy,
|
6072 | MediumSpace: MediumSpace,
|
6073 | Mellintrf: Mellintrf,
|
6074 | Mfr: Mfr,
|
6075 | MinusPlus: MinusPlus,
|
6076 | Mopf: Mopf,
|
6077 | Mscr: Mscr,
|
6078 | Mu: Mu,
|
6079 | NJcy: NJcy,
|
6080 | Nacute: Nacute,
|
6081 | Ncaron: Ncaron,
|
6082 | Ncedil: Ncedil,
|
6083 | Ncy: Ncy,
|
6084 | NegativeMediumSpace: NegativeMediumSpace,
|
6085 | NegativeThickSpace: NegativeThickSpace,
|
6086 | NegativeThinSpace: NegativeThinSpace,
|
6087 | NegativeVeryThinSpace: NegativeVeryThinSpace,
|
6088 | NestedGreaterGreater: NestedGreaterGreater,
|
6089 | NestedLessLess: NestedLessLess,
|
6090 | NewLine: NewLine,
|
6091 | Nfr: Nfr,
|
6092 | NoBreak: NoBreak,
|
6093 | NonBreakingSpace: NonBreakingSpace,
|
6094 | Nopf: Nopf,
|
6095 | Not: Not,
|
6096 | NotCongruent: NotCongruent,
|
6097 | NotCupCap: NotCupCap,
|
6098 | NotDoubleVerticalBar: NotDoubleVerticalBar,
|
6099 | NotElement: NotElement,
|
6100 | NotEqual: NotEqual,
|
6101 | NotEqualTilde: NotEqualTilde,
|
6102 | NotExists: NotExists,
|
6103 | NotGreater: NotGreater,
|
6104 | NotGreaterEqual: NotGreaterEqual,
|
6105 | NotGreaterFullEqual: NotGreaterFullEqual,
|
6106 | NotGreaterGreater: NotGreaterGreater,
|
6107 | NotGreaterLess: NotGreaterLess,
|
6108 | NotGreaterSlantEqual: NotGreaterSlantEqual,
|
6109 | NotGreaterTilde: NotGreaterTilde,
|
6110 | NotHumpDownHump: NotHumpDownHump,
|
6111 | NotHumpEqual: NotHumpEqual,
|
6112 | NotLeftTriangle: NotLeftTriangle,
|
6113 | NotLeftTriangleBar: NotLeftTriangleBar,
|
6114 | NotLeftTriangleEqual: NotLeftTriangleEqual,
|
6115 | NotLess: NotLess,
|
6116 | NotLessEqual: NotLessEqual,
|
6117 | NotLessGreater: NotLessGreater,
|
6118 | NotLessLess: NotLessLess,
|
6119 | NotLessSlantEqual: NotLessSlantEqual,
|
6120 | NotLessTilde: NotLessTilde,
|
6121 | NotNestedGreaterGreater: NotNestedGreaterGreater,
|
6122 | NotNestedLessLess: NotNestedLessLess,
|
6123 | NotPrecedes: NotPrecedes,
|
6124 | NotPrecedesEqual: NotPrecedesEqual,
|
6125 | NotPrecedesSlantEqual: NotPrecedesSlantEqual,
|
6126 | NotReverseElement: NotReverseElement,
|
6127 | NotRightTriangle: NotRightTriangle,
|
6128 | NotRightTriangleBar: NotRightTriangleBar,
|
6129 | NotRightTriangleEqual: NotRightTriangleEqual,
|
6130 | NotSquareSubset: NotSquareSubset,
|
6131 | NotSquareSubsetEqual: NotSquareSubsetEqual,
|
6132 | NotSquareSuperset: NotSquareSuperset,
|
6133 | NotSquareSupersetEqual: NotSquareSupersetEqual,
|
6134 | NotSubset: NotSubset,
|
6135 | NotSubsetEqual: NotSubsetEqual,
|
6136 | NotSucceeds: NotSucceeds,
|
6137 | NotSucceedsEqual: NotSucceedsEqual,
|
6138 | NotSucceedsSlantEqual: NotSucceedsSlantEqual,
|
6139 | NotSucceedsTilde: NotSucceedsTilde,
|
6140 | NotSuperset: NotSuperset,
|
6141 | NotSupersetEqual: NotSupersetEqual,
|
6142 | NotTilde: NotTilde,
|
6143 | NotTildeEqual: NotTildeEqual,
|
6144 | NotTildeFullEqual: NotTildeFullEqual,
|
6145 | NotTildeTilde: NotTildeTilde,
|
6146 | NotVerticalBar: NotVerticalBar,
|
6147 | Nscr: Nscr,
|
6148 | Ntild: Ntild,
|
6149 | Ntilde: Ntilde,
|
6150 | Nu: Nu,
|
6151 | OElig: OElig,
|
6152 | Oacut: Oacut,
|
6153 | Oacute: Oacute,
|
6154 | Ocir: Ocir,
|
6155 | Ocirc: Ocirc,
|
6156 | Ocy: Ocy,
|
6157 | Odblac: Odblac,
|
6158 | Ofr: Ofr,
|
6159 | Ograv: Ograv,
|
6160 | Ograve: Ograve,
|
6161 | Omacr: Omacr,
|
6162 | Omega: Omega,
|
6163 | Omicron: Omicron,
|
6164 | Oopf: Oopf,
|
6165 | OpenCurlyDoubleQuote: OpenCurlyDoubleQuote,
|
6166 | OpenCurlyQuote: OpenCurlyQuote,
|
6167 | Or: Or,
|
6168 | Oscr: Oscr,
|
6169 | Oslas: Oslas,
|
6170 | Oslash: Oslash,
|
6171 | Otild: Otild,
|
6172 | Otilde: Otilde,
|
6173 | Otimes: Otimes,
|
6174 | Oum: Oum,
|
6175 | Ouml: Ouml,
|
6176 | OverBar: OverBar,
|
6177 | OverBrace: OverBrace,
|
6178 | OverBracket: OverBracket,
|
6179 | OverParenthesis: OverParenthesis,
|
6180 | PartialD: PartialD,
|
6181 | Pcy: Pcy,
|
6182 | Pfr: Pfr,
|
6183 | Phi: Phi,
|
6184 | Pi: Pi,
|
6185 | PlusMinus: PlusMinus,
|
6186 | Poincareplane: Poincareplane,
|
6187 | Popf: Popf,
|
6188 | Pr: Pr,
|
6189 | Precedes: Precedes,
|
6190 | PrecedesEqual: PrecedesEqual,
|
6191 | PrecedesSlantEqual: PrecedesSlantEqual,
|
6192 | PrecedesTilde: PrecedesTilde,
|
6193 | Prime: Prime,
|
6194 | Product: Product,
|
6195 | Proportion: Proportion,
|
6196 | Proportional: Proportional,
|
6197 | Pscr: Pscr,
|
6198 | Psi: Psi,
|
6199 | QUO: QUO,
|
6200 | QUOT: QUOT,
|
6201 | Qfr: Qfr,
|
6202 | Qopf: Qopf,
|
6203 | Qscr: Qscr,
|
6204 | RBarr: RBarr,
|
6205 | RE: RE,
|
6206 | REG: REG,
|
6207 | Racute: Racute,
|
6208 | Rang: Rang,
|
6209 | Rarr: Rarr,
|
6210 | Rarrtl: Rarrtl,
|
6211 | Rcaron: Rcaron,
|
6212 | Rcedil: Rcedil,
|
6213 | Rcy: Rcy,
|
6214 | Re: Re,
|
6215 | ReverseElement: ReverseElement,
|
6216 | ReverseEquilibrium: ReverseEquilibrium,
|
6217 | ReverseUpEquilibrium: ReverseUpEquilibrium,
|
6218 | Rfr: Rfr,
|
6219 | Rho: Rho,
|
6220 | RightAngleBracket: RightAngleBracket,
|
6221 | RightArrow: RightArrow,
|
6222 | RightArrowBar: RightArrowBar,
|
6223 | RightArrowLeftArrow: RightArrowLeftArrow,
|
6224 | RightCeiling: RightCeiling,
|
6225 | RightDoubleBracket: RightDoubleBracket,
|
6226 | RightDownTeeVector: RightDownTeeVector,
|
6227 | RightDownVector: RightDownVector,
|
6228 | RightDownVectorBar: RightDownVectorBar,
|
6229 | RightFloor: RightFloor,
|
6230 | RightTee: RightTee,
|
6231 | RightTeeArrow: RightTeeArrow,
|
6232 | RightTeeVector: RightTeeVector,
|
6233 | RightTriangle: RightTriangle,
|
6234 | RightTriangleBar: RightTriangleBar,
|
6235 | RightTriangleEqual: RightTriangleEqual,
|
6236 | RightUpDownVector: RightUpDownVector,
|
6237 | RightUpTeeVector: RightUpTeeVector,
|
6238 | RightUpVector: RightUpVector,
|
6239 | RightUpVectorBar: RightUpVectorBar,
|
6240 | RightVector: RightVector,
|
6241 | RightVectorBar: RightVectorBar,
|
6242 | Rightarrow: Rightarrow,
|
6243 | Ropf: Ropf,
|
6244 | RoundImplies: RoundImplies,
|
6245 | Rrightarrow: Rrightarrow,
|
6246 | Rscr: Rscr,
|
6247 | Rsh: Rsh,
|
6248 | RuleDelayed: RuleDelayed,
|
6249 | SHCHcy: SHCHcy,
|
6250 | SHcy: SHcy,
|
6251 | SOFTcy: SOFTcy,
|
6252 | Sacute: Sacute,
|
6253 | Sc: Sc,
|
6254 | Scaron: Scaron,
|
6255 | Scedil: Scedil,
|
6256 | Scirc: Scirc,
|
6257 | Scy: Scy,
|
6258 | Sfr: Sfr,
|
6259 | ShortDownArrow: ShortDownArrow,
|
6260 | ShortLeftArrow: ShortLeftArrow,
|
6261 | ShortRightArrow: ShortRightArrow,
|
6262 | ShortUpArrow: ShortUpArrow,
|
6263 | Sigma: Sigma,
|
6264 | SmallCircle: SmallCircle,
|
6265 | Sopf: Sopf,
|
6266 | Sqrt: Sqrt,
|
6267 | Square: Square,
|
6268 | SquareIntersection: SquareIntersection,
|
6269 | SquareSubset: SquareSubset,
|
6270 | SquareSubsetEqual: SquareSubsetEqual,
|
6271 | SquareSuperset: SquareSuperset,
|
6272 | SquareSupersetEqual: SquareSupersetEqual,
|
6273 | SquareUnion: SquareUnion,
|
6274 | Sscr: Sscr,
|
6275 | Star: Star,
|
6276 | Sub: Sub,
|
6277 | Subset: Subset,
|
6278 | SubsetEqual: SubsetEqual,
|
6279 | Succeeds: Succeeds,
|
6280 | SucceedsEqual: SucceedsEqual,
|
6281 | SucceedsSlantEqual: SucceedsSlantEqual,
|
6282 | SucceedsTilde: SucceedsTilde,
|
6283 | SuchThat: SuchThat,
|
6284 | Sum: Sum,
|
6285 | Sup: Sup,
|
6286 | Superset: Superset,
|
6287 | SupersetEqual: SupersetEqual,
|
6288 | Supset: Supset,
|
6289 | THOR: THOR,
|
6290 | THORN: THORN,
|
6291 | TRADE: TRADE,
|
6292 | TSHcy: TSHcy,
|
6293 | TScy: TScy,
|
6294 | Tab: Tab,
|
6295 | Tau: Tau,
|
6296 | Tcaron: Tcaron,
|
6297 | Tcedil: Tcedil,
|
6298 | Tcy: Tcy,
|
6299 | Tfr: Tfr,
|
6300 | Therefore: Therefore,
|
6301 | Theta: Theta,
|
6302 | ThickSpace: ThickSpace,
|
6303 | ThinSpace: ThinSpace,
|
6304 | Tilde: Tilde,
|
6305 | TildeEqual: TildeEqual,
|
6306 | TildeFullEqual: TildeFullEqual,
|
6307 | TildeTilde: TildeTilde,
|
6308 | Topf: Topf,
|
6309 | TripleDot: TripleDot,
|
6310 | Tscr: Tscr,
|
6311 | Tstrok: Tstrok,
|
6312 | Uacut: Uacut,
|
6313 | Uacute: Uacute,
|
6314 | Uarr: Uarr,
|
6315 | Uarrocir: Uarrocir,
|
6316 | Ubrcy: Ubrcy,
|
6317 | Ubreve: Ubreve,
|
6318 | Ucir: Ucir,
|
6319 | Ucirc: Ucirc,
|
6320 | Ucy: Ucy,
|
6321 | Udblac: Udblac,
|
6322 | Ufr: Ufr,
|
6323 | Ugrav: Ugrav,
|
6324 | Ugrave: Ugrave,
|
6325 | Umacr: Umacr,
|
6326 | UnderBar: UnderBar,
|
6327 | UnderBrace: UnderBrace,
|
6328 | UnderBracket: UnderBracket,
|
6329 | UnderParenthesis: UnderParenthesis,
|
6330 | Union: Union,
|
6331 | UnionPlus: UnionPlus,
|
6332 | Uogon: Uogon,
|
6333 | Uopf: Uopf,
|
6334 | UpArrow: UpArrow,
|
6335 | UpArrowBar: UpArrowBar,
|
6336 | UpArrowDownArrow: UpArrowDownArrow,
|
6337 | UpDownArrow: UpDownArrow,
|
6338 | UpEquilibrium: UpEquilibrium,
|
6339 | UpTee: UpTee,
|
6340 | UpTeeArrow: UpTeeArrow,
|
6341 | Uparrow: Uparrow,
|
6342 | Updownarrow: Updownarrow,
|
6343 | UpperLeftArrow: UpperLeftArrow,
|
6344 | UpperRightArrow: UpperRightArrow,
|
6345 | Upsi: Upsi,
|
6346 | Upsilon: Upsilon,
|
6347 | Uring: Uring,
|
6348 | Uscr: Uscr,
|
6349 | Utilde: Utilde,
|
6350 | Uum: Uum,
|
6351 | Uuml: Uuml,
|
6352 | VDash: VDash,
|
6353 | Vbar: Vbar,
|
6354 | Vcy: Vcy,
|
6355 | Vdash: Vdash,
|
6356 | Vdashl: Vdashl,
|
6357 | Vee: Vee,
|
6358 | Verbar: Verbar,
|
6359 | Vert: Vert,
|
6360 | VerticalBar: VerticalBar,
|
6361 | VerticalLine: VerticalLine,
|
6362 | VerticalSeparator: VerticalSeparator,
|
6363 | VerticalTilde: VerticalTilde,
|
6364 | VeryThinSpace: VeryThinSpace,
|
6365 | Vfr: Vfr,
|
6366 | Vopf: Vopf,
|
6367 | Vscr: Vscr,
|
6368 | Vvdash: Vvdash,
|
6369 | Wcirc: Wcirc,
|
6370 | Wedge: Wedge,
|
6371 | Wfr: Wfr,
|
6372 | Wopf: Wopf,
|
6373 | Wscr: Wscr,
|
6374 | Xfr: Xfr,
|
6375 | Xi: Xi,
|
6376 | Xopf: Xopf,
|
6377 | Xscr: Xscr,
|
6378 | YAcy: YAcy,
|
6379 | YIcy: YIcy,
|
6380 | YUcy: YUcy,
|
6381 | Yacut: Yacut,
|
6382 | Yacute: Yacute,
|
6383 | Ycirc: Ycirc,
|
6384 | Ycy: Ycy,
|
6385 | Yfr: Yfr,
|
6386 | Yopf: Yopf,
|
6387 | Yscr: Yscr,
|
6388 | Yuml: Yuml,
|
6389 | ZHcy: ZHcy,
|
6390 | Zacute: Zacute,
|
6391 | Zcaron: Zcaron,
|
6392 | Zcy: Zcy,
|
6393 | Zdot: Zdot,
|
6394 | ZeroWidthSpace: ZeroWidthSpace,
|
6395 | Zeta: Zeta,
|
6396 | Zfr: Zfr,
|
6397 | Zopf: Zopf,
|
6398 | Zscr: Zscr,
|
6399 | aacut: aacut,
|
6400 | aacute: aacute,
|
6401 | abreve: abreve,
|
6402 | ac: ac,
|
6403 | acE: acE,
|
6404 | acd: acd,
|
6405 | acir: acir,
|
6406 | acirc: acirc,
|
6407 | acut: acut,
|
6408 | acute: acute,
|
6409 | acy: acy,
|
6410 | aeli: aeli,
|
6411 | aelig: aelig,
|
6412 | af: af,
|
6413 | afr: afr,
|
6414 | agrav: agrav,
|
6415 | agrave: agrave,
|
6416 | alefsym: alefsym,
|
6417 | aleph: aleph,
|
6418 | alpha: alpha,
|
6419 | amacr: amacr,
|
6420 | amalg: amalg,
|
6421 | am: am,
|
6422 | amp: amp,
|
6423 | and: and,
|
6424 | andand: andand,
|
6425 | andd: andd,
|
6426 | andslope: andslope,
|
6427 | andv: andv,
|
6428 | ang: ang,
|
6429 | ange: ange,
|
6430 | angle: angle,
|
6431 | angmsd: angmsd,
|
6432 | angmsdaa: angmsdaa,
|
6433 | angmsdab: angmsdab,
|
6434 | angmsdac: angmsdac,
|
6435 | angmsdad: angmsdad,
|
6436 | angmsdae: angmsdae,
|
6437 | angmsdaf: angmsdaf,
|
6438 | angmsdag: angmsdag,
|
6439 | angmsdah: angmsdah,
|
6440 | angrt: angrt,
|
6441 | angrtvb: angrtvb,
|
6442 | angrtvbd: angrtvbd,
|
6443 | angsph: angsph,
|
6444 | angst: angst,
|
6445 | angzarr: angzarr,
|
6446 | aogon: aogon,
|
6447 | aopf: aopf,
|
6448 | ap: ap,
|
6449 | apE: apE,
|
6450 | apacir: apacir,
|
6451 | ape: ape,
|
6452 | apid: apid,
|
6453 | apos: apos,
|
6454 | approx: approx,
|
6455 | approxeq: approxeq,
|
6456 | arin: arin,
|
6457 | aring: aring,
|
6458 | ascr: ascr,
|
6459 | ast: ast,
|
6460 | asymp: asymp,
|
6461 | asympeq: asympeq,
|
6462 | atild: atild,
|
6463 | atilde: atilde,
|
6464 | aum: aum,
|
6465 | auml: auml,
|
6466 | awconint: awconint,
|
6467 | awint: awint,
|
6468 | bNot: bNot,
|
6469 | backcong: backcong,
|
6470 | backepsilon: backepsilon,
|
6471 | backprime: backprime,
|
6472 | backsim: backsim,
|
6473 | backsimeq: backsimeq,
|
6474 | barvee: barvee,
|
6475 | barwed: barwed,
|
6476 | barwedge: barwedge,
|
6477 | bbrk: bbrk,
|
6478 | bbrktbrk: bbrktbrk,
|
6479 | bcong: bcong,
|
6480 | bcy: bcy,
|
6481 | bdquo: bdquo,
|
6482 | becaus: becaus,
|
6483 | because: because,
|
6484 | bemptyv: bemptyv,
|
6485 | bepsi: bepsi,
|
6486 | bernou: bernou,
|
6487 | beta: beta,
|
6488 | beth: beth,
|
6489 | between: between,
|
6490 | bfr: bfr,
|
6491 | bigcap: bigcap,
|
6492 | bigcirc: bigcirc,
|
6493 | bigcup: bigcup,
|
6494 | bigodot: bigodot,
|
6495 | bigoplus: bigoplus,
|
6496 | bigotimes: bigotimes,
|
6497 | bigsqcup: bigsqcup,
|
6498 | bigstar: bigstar,
|
6499 | bigtriangledown: bigtriangledown,
|
6500 | bigtriangleup: bigtriangleup,
|
6501 | biguplus: biguplus,
|
6502 | bigvee: bigvee,
|
6503 | bigwedge: bigwedge,
|
6504 | bkarow: bkarow,
|
6505 | blacklozenge: blacklozenge,
|
6506 | blacksquare: blacksquare,
|
6507 | blacktriangle: blacktriangle,
|
6508 | blacktriangledown: blacktriangledown,
|
6509 | blacktriangleleft: blacktriangleleft,
|
6510 | blacktriangleright: blacktriangleright,
|
6511 | blank: blank,
|
6512 | blk12: blk12,
|
6513 | blk14: blk14,
|
6514 | blk34: blk34,
|
6515 | block: block,
|
6516 | bne: bne,
|
6517 | bnequiv: bnequiv,
|
6518 | bnot: bnot,
|
6519 | bopf: bopf,
|
6520 | bot: bot,
|
6521 | bottom: bottom,
|
6522 | bowtie: bowtie,
|
6523 | boxDL: boxDL,
|
6524 | boxDR: boxDR,
|
6525 | boxDl: boxDl,
|
6526 | boxDr: boxDr,
|
6527 | boxH: boxH,
|
6528 | boxHD: boxHD,
|
6529 | boxHU: boxHU,
|
6530 | boxHd: boxHd,
|
6531 | boxHu: boxHu,
|
6532 | boxUL: boxUL,
|
6533 | boxUR: boxUR,
|
6534 | boxUl: boxUl,
|
6535 | boxUr: boxUr,
|
6536 | boxV: boxV,
|
6537 | boxVH: boxVH,
|
6538 | boxVL: boxVL,
|
6539 | boxVR: boxVR,
|
6540 | boxVh: boxVh,
|
6541 | boxVl: boxVl,
|
6542 | boxVr: boxVr,
|
6543 | boxbox: boxbox,
|
6544 | boxdL: boxdL,
|
6545 | boxdR: boxdR,
|
6546 | boxdl: boxdl,
|
6547 | boxdr: boxdr,
|
6548 | boxh: boxh,
|
6549 | boxhD: boxhD,
|
6550 | boxhU: boxhU,
|
6551 | boxhd: boxhd,
|
6552 | boxhu: boxhu,
|
6553 | boxminus: boxminus,
|
6554 | boxplus: boxplus,
|
6555 | boxtimes: boxtimes,
|
6556 | boxuL: boxuL,
|
6557 | boxuR: boxuR,
|
6558 | boxul: boxul,
|
6559 | boxur: boxur,
|
6560 | boxv: boxv,
|
6561 | boxvH: boxvH,
|
6562 | boxvL: boxvL,
|
6563 | boxvR: boxvR,
|
6564 | boxvh: boxvh,
|
6565 | boxvl: boxvl,
|
6566 | boxvr: boxvr,
|
6567 | bprime: bprime,
|
6568 | breve: breve,
|
6569 | brvba: brvba,
|
6570 | brvbar: brvbar,
|
6571 | bscr: bscr,
|
6572 | bsemi: bsemi,
|
6573 | bsim: bsim,
|
6574 | bsime: bsime,
|
6575 | bsol: bsol,
|
6576 | bsolb: bsolb,
|
6577 | bsolhsub: bsolhsub,
|
6578 | bull: bull,
|
6579 | bullet: bullet,
|
6580 | bump: bump,
|
6581 | bumpE: bumpE,
|
6582 | bumpe: bumpe,
|
6583 | bumpeq: bumpeq,
|
6584 | cacute: cacute,
|
6585 | cap: cap,
|
6586 | capand: capand,
|
6587 | capbrcup: capbrcup,
|
6588 | capcap: capcap,
|
6589 | capcup: capcup,
|
6590 | capdot: capdot,
|
6591 | caps: caps,
|
6592 | caret: caret,
|
6593 | caron: caron,
|
6594 | ccaps: ccaps,
|
6595 | ccaron: ccaron,
|
6596 | ccedi: ccedi,
|
6597 | ccedil: ccedil,
|
6598 | ccirc: ccirc,
|
6599 | ccups: ccups,
|
6600 | ccupssm: ccupssm,
|
6601 | cdot: cdot,
|
6602 | cedi: cedi,
|
6603 | cedil: cedil,
|
6604 | cemptyv: cemptyv,
|
6605 | cen: cen,
|
6606 | cent: cent,
|
6607 | centerdot: centerdot,
|
6608 | cfr: cfr,
|
6609 | chcy: chcy,
|
6610 | check: check,
|
6611 | checkmark: checkmark,
|
6612 | chi: chi,
|
6613 | cir: cir,
|
6614 | cirE: cirE,
|
6615 | circ: circ,
|
6616 | circeq: circeq,
|
6617 | circlearrowleft: circlearrowleft,
|
6618 | circlearrowright: circlearrowright,
|
6619 | circledR: circledR,
|
6620 | circledS: circledS,
|
6621 | circledast: circledast,
|
6622 | circledcirc: circledcirc,
|
6623 | circleddash: circleddash,
|
6624 | cire: cire,
|
6625 | cirfnint: cirfnint,
|
6626 | cirmid: cirmid,
|
6627 | cirscir: cirscir,
|
6628 | clubs: clubs,
|
6629 | clubsuit: clubsuit,
|
6630 | colon: colon,
|
6631 | colone: colone,
|
6632 | coloneq: coloneq,
|
6633 | comma: comma,
|
6634 | commat: commat,
|
6635 | comp: comp,
|
6636 | compfn: compfn,
|
6637 | complement: complement,
|
6638 | complexes: complexes,
|
6639 | cong: cong,
|
6640 | congdot: congdot,
|
6641 | conint: conint,
|
6642 | copf: copf,
|
6643 | coprod: coprod,
|
6644 | cop: cop,
|
6645 | copy: copy,
|
6646 | copysr: copysr,
|
6647 | crarr: crarr,
|
6648 | cross: cross,
|
6649 | cscr: cscr,
|
6650 | csub: csub,
|
6651 | csube: csube,
|
6652 | csup: csup,
|
6653 | csupe: csupe,
|
6654 | ctdot: ctdot,
|
6655 | cudarrl: cudarrl,
|
6656 | cudarrr: cudarrr,
|
6657 | cuepr: cuepr,
|
6658 | cuesc: cuesc,
|
6659 | cularr: cularr,
|
6660 | cularrp: cularrp,
|
6661 | cup: cup,
|
6662 | cupbrcap: cupbrcap,
|
6663 | cupcap: cupcap,
|
6664 | cupcup: cupcup,
|
6665 | cupdot: cupdot,
|
6666 | cupor: cupor,
|
6667 | cups: cups,
|
6668 | curarr: curarr,
|
6669 | curarrm: curarrm,
|
6670 | curlyeqprec: curlyeqprec,
|
6671 | curlyeqsucc: curlyeqsucc,
|
6672 | curlyvee: curlyvee,
|
6673 | curlywedge: curlywedge,
|
6674 | curre: curre,
|
6675 | curren: curren,
|
6676 | curvearrowleft: curvearrowleft,
|
6677 | curvearrowright: curvearrowright,
|
6678 | cuvee: cuvee,
|
6679 | cuwed: cuwed,
|
6680 | cwconint: cwconint,
|
6681 | cwint: cwint,
|
6682 | cylcty: cylcty,
|
6683 | dArr: dArr,
|
6684 | dHar: dHar,
|
6685 | dagger: dagger,
|
6686 | daleth: daleth,
|
6687 | darr: darr,
|
6688 | dash: dash,
|
6689 | dashv: dashv,
|
6690 | dbkarow: dbkarow,
|
6691 | dblac: dblac,
|
6692 | dcaron: dcaron,
|
6693 | dcy: dcy,
|
6694 | dd: dd,
|
6695 | ddagger: ddagger,
|
6696 | ddarr: ddarr,
|
6697 | ddotseq: ddotseq,
|
6698 | de: de,
|
6699 | deg: deg,
|
6700 | delta: delta,
|
6701 | demptyv: demptyv,
|
6702 | dfisht: dfisht,
|
6703 | dfr: dfr,
|
6704 | dharl: dharl,
|
6705 | dharr: dharr,
|
6706 | diam: diam,
|
6707 | diamond: diamond,
|
6708 | diamondsuit: diamondsuit,
|
6709 | diams: diams,
|
6710 | die: die,
|
6711 | digamma: digamma,
|
6712 | disin: disin,
|
6713 | div: div,
|
6714 | divid: divid,
|
6715 | divide: divide,
|
6716 | divideontimes: divideontimes,
|
6717 | divonx: divonx,
|
6718 | djcy: djcy,
|
6719 | dlcorn: dlcorn,
|
6720 | dlcrop: dlcrop,
|
6721 | dollar: dollar,
|
6722 | dopf: dopf,
|
6723 | dot: dot,
|
6724 | doteq: doteq,
|
6725 | doteqdot: doteqdot,
|
6726 | dotminus: dotminus,
|
6727 | dotplus: dotplus,
|
6728 | dotsquare: dotsquare,
|
6729 | doublebarwedge: doublebarwedge,
|
6730 | downarrow: downarrow,
|
6731 | downdownarrows: downdownarrows,
|
6732 | downharpoonleft: downharpoonleft,
|
6733 | downharpoonright: downharpoonright,
|
6734 | drbkarow: drbkarow,
|
6735 | drcorn: drcorn,
|
6736 | drcrop: drcrop,
|
6737 | dscr: dscr,
|
6738 | dscy: dscy,
|
6739 | dsol: dsol,
|
6740 | dstrok: dstrok,
|
6741 | dtdot: dtdot,
|
6742 | dtri: dtri,
|
6743 | dtrif: dtrif,
|
6744 | duarr: duarr,
|
6745 | duhar: duhar,
|
6746 | dwangle: dwangle,
|
6747 | dzcy: dzcy,
|
6748 | dzigrarr: dzigrarr,
|
6749 | eDDot: eDDot,
|
6750 | eDot: eDot,
|
6751 | eacut: eacut,
|
6752 | eacute: eacute,
|
6753 | easter: easter,
|
6754 | ecaron: ecaron,
|
6755 | ecir: ecir,
|
6756 | ecirc: ecirc,
|
6757 | ecolon: ecolon,
|
6758 | ecy: ecy,
|
6759 | edot: edot,
|
6760 | ee: ee,
|
6761 | efDot: efDot,
|
6762 | efr: efr,
|
6763 | eg: eg,
|
6764 | egrav: egrav,
|
6765 | egrave: egrave,
|
6766 | egs: egs,
|
6767 | egsdot: egsdot,
|
6768 | el: el,
|
6769 | elinters: elinters,
|
6770 | ell: ell,
|
6771 | els: els,
|
6772 | elsdot: elsdot,
|
6773 | emacr: emacr,
|
6774 | empty: empty,
|
6775 | emptyset: emptyset,
|
6776 | emptyv: emptyv,
|
6777 | emsp13: emsp13,
|
6778 | emsp14: emsp14,
|
6779 | emsp: emsp,
|
6780 | eng: eng,
|
6781 | ensp: ensp,
|
6782 | eogon: eogon,
|
6783 | eopf: eopf,
|
6784 | epar: epar,
|
6785 | eparsl: eparsl,
|
6786 | eplus: eplus,
|
6787 | epsi: epsi,
|
6788 | epsilon: epsilon,
|
6789 | epsiv: epsiv,
|
6790 | eqcirc: eqcirc,
|
6791 | eqcolon: eqcolon,
|
6792 | eqsim: eqsim,
|
6793 | eqslantgtr: eqslantgtr,
|
6794 | eqslantless: eqslantless,
|
6795 | equals: equals,
|
6796 | equest: equest,
|
6797 | equiv: equiv,
|
6798 | equivDD: equivDD,
|
6799 | eqvparsl: eqvparsl,
|
6800 | erDot: erDot,
|
6801 | erarr: erarr,
|
6802 | escr: escr,
|
6803 | esdot: esdot,
|
6804 | esim: esim,
|
6805 | eta: eta,
|
6806 | et: et,
|
6807 | eth: eth,
|
6808 | eum: eum,
|
6809 | euml: euml,
|
6810 | euro: euro,
|
6811 | excl: excl,
|
6812 | exist: exist,
|
6813 | expectation: expectation,
|
6814 | exponentiale: exponentiale,
|
6815 | fallingdotseq: fallingdotseq,
|
6816 | fcy: fcy,
|
6817 | female: female,
|
6818 | ffilig: ffilig,
|
6819 | fflig: fflig,
|
6820 | ffllig: ffllig,
|
6821 | ffr: ffr,
|
6822 | filig: filig,
|
6823 | fjlig: fjlig,
|
6824 | flat: flat,
|
6825 | fllig: fllig,
|
6826 | fltns: fltns,
|
6827 | fnof: fnof,
|
6828 | fopf: fopf,
|
6829 | forall: forall,
|
6830 | fork: fork,
|
6831 | forkv: forkv,
|
6832 | fpartint: fpartint,
|
6833 | frac1: frac1,
|
6834 | frac12: frac12,
|
6835 | frac13: frac13,
|
6836 | frac14: frac14,
|
6837 | frac15: frac15,
|
6838 | frac16: frac16,
|
6839 | frac18: frac18,
|
6840 | frac23: frac23,
|
6841 | frac25: frac25,
|
6842 | frac3: frac3,
|
6843 | frac34: frac34,
|
6844 | frac35: frac35,
|
6845 | frac38: frac38,
|
6846 | frac45: frac45,
|
6847 | frac56: frac56,
|
6848 | frac58: frac58,
|
6849 | frac78: frac78,
|
6850 | frasl: frasl,
|
6851 | frown: frown,
|
6852 | fscr: fscr,
|
6853 | gE: gE,
|
6854 | gEl: gEl,
|
6855 | gacute: gacute,
|
6856 | gamma: gamma,
|
6857 | gammad: gammad,
|
6858 | gap: gap,
|
6859 | gbreve: gbreve,
|
6860 | gcirc: gcirc,
|
6861 | gcy: gcy,
|
6862 | gdot: gdot,
|
6863 | ge: ge,
|
6864 | gel: gel,
|
6865 | geq: geq,
|
6866 | geqq: geqq,
|
6867 | geqslant: geqslant,
|
6868 | ges: ges,
|
6869 | gescc: gescc,
|
6870 | gesdot: gesdot,
|
6871 | gesdoto: gesdoto,
|
6872 | gesdotol: gesdotol,
|
6873 | gesl: gesl,
|
6874 | gesles: gesles,
|
6875 | gfr: gfr,
|
6876 | gg: gg,
|
6877 | ggg: ggg,
|
6878 | gimel: gimel,
|
6879 | gjcy: gjcy,
|
6880 | gl: gl,
|
6881 | glE: glE,
|
6882 | gla: gla,
|
6883 | glj: glj,
|
6884 | gnE: gnE,
|
6885 | gnap: gnap,
|
6886 | gnapprox: gnapprox,
|
6887 | gne: gne,
|
6888 | gneq: gneq,
|
6889 | gneqq: gneqq,
|
6890 | gnsim: gnsim,
|
6891 | gopf: gopf,
|
6892 | grave: grave,
|
6893 | gscr: gscr,
|
6894 | gsim: gsim,
|
6895 | gsime: gsime,
|
6896 | gsiml: gsiml,
|
6897 | g: g,
|
6898 | gt: gt,
|
6899 | gtcc: gtcc,
|
6900 | gtcir: gtcir,
|
6901 | gtdot: gtdot,
|
6902 | gtlPar: gtlPar,
|
6903 | gtquest: gtquest,
|
6904 | gtrapprox: gtrapprox,
|
6905 | gtrarr: gtrarr,
|
6906 | gtrdot: gtrdot,
|
6907 | gtreqless: gtreqless,
|
6908 | gtreqqless: gtreqqless,
|
6909 | gtrless: gtrless,
|
6910 | gtrsim: gtrsim,
|
6911 | gvertneqq: gvertneqq,
|
6912 | gvnE: gvnE,
|
6913 | hArr: hArr,
|
6914 | hairsp: hairsp,
|
6915 | half: half,
|
6916 | hamilt: hamilt,
|
6917 | hardcy: hardcy,
|
6918 | harr: harr,
|
6919 | harrcir: harrcir,
|
6920 | harrw: harrw,
|
6921 | hbar: hbar,
|
6922 | hcirc: hcirc,
|
6923 | hearts: hearts,
|
6924 | heartsuit: heartsuit,
|
6925 | hellip: hellip,
|
6926 | hercon: hercon,
|
6927 | hfr: hfr,
|
6928 | hksearow: hksearow,
|
6929 | hkswarow: hkswarow,
|
6930 | hoarr: hoarr,
|
6931 | homtht: homtht,
|
6932 | hookleftarrow: hookleftarrow,
|
6933 | hookrightarrow: hookrightarrow,
|
6934 | hopf: hopf,
|
6935 | horbar: horbar,
|
6936 | hscr: hscr,
|
6937 | hslash: hslash,
|
6938 | hstrok: hstrok,
|
6939 | hybull: hybull,
|
6940 | hyphen: hyphen,
|
6941 | iacut: iacut,
|
6942 | iacute: iacute,
|
6943 | ic: ic,
|
6944 | icir: icir,
|
6945 | icirc: icirc,
|
6946 | icy: icy,
|
6947 | iecy: iecy,
|
6948 | iexc: iexc,
|
6949 | iexcl: iexcl,
|
6950 | iff: iff,
|
6951 | ifr: ifr,
|
6952 | igrav: igrav,
|
6953 | igrave: igrave,
|
6954 | ii: ii,
|
6955 | iiiint: iiiint,
|
6956 | iiint: iiint,
|
6957 | iinfin: iinfin,
|
6958 | iiota: iiota,
|
6959 | ijlig: ijlig,
|
6960 | imacr: imacr,
|
6961 | image: image,
|
6962 | imagline: imagline,
|
6963 | imagpart: imagpart,
|
6964 | imath: imath,
|
6965 | imof: imof,
|
6966 | imped: imped,
|
6967 | "in": "∈",
|
6968 | incare: incare,
|
6969 | infin: infin,
|
6970 | infintie: infintie,
|
6971 | inodot: inodot,
|
6972 | int: int,
|
6973 | intcal: intcal,
|
6974 | integers: integers,
|
6975 | intercal: intercal,
|
6976 | intlarhk: intlarhk,
|
6977 | intprod: intprod,
|
6978 | iocy: iocy,
|
6979 | iogon: iogon,
|
6980 | iopf: iopf,
|
6981 | iota: iota,
|
6982 | iprod: iprod,
|
6983 | iques: iques,
|
6984 | iquest: iquest,
|
6985 | iscr: iscr,
|
6986 | isin: isin,
|
6987 | isinE: isinE,
|
6988 | isindot: isindot,
|
6989 | isins: isins,
|
6990 | isinsv: isinsv,
|
6991 | isinv: isinv,
|
6992 | it: it,
|
6993 | itilde: itilde,
|
6994 | iukcy: iukcy,
|
6995 | ium: ium,
|
6996 | iuml: iuml,
|
6997 | jcirc: jcirc,
|
6998 | jcy: jcy,
|
6999 | jfr: jfr,
|
7000 | jmath: jmath,
|
7001 | jopf: jopf,
|
7002 | jscr: jscr,
|
7003 | jsercy: jsercy,
|
7004 | jukcy: jukcy,
|
7005 | kappa: kappa,
|
7006 | kappav: kappav,
|
7007 | kcedil: kcedil,
|
7008 | kcy: kcy,
|
7009 | kfr: kfr,
|
7010 | kgreen: kgreen,
|
7011 | khcy: khcy,
|
7012 | kjcy: kjcy,
|
7013 | kopf: kopf,
|
7014 | kscr: kscr,
|
7015 | lAarr: lAarr,
|
7016 | lArr: lArr,
|
7017 | lAtail: lAtail,
|
7018 | lBarr: lBarr,
|
7019 | lE: lE,
|
7020 | lEg: lEg,
|
7021 | lHar: lHar,
|
7022 | lacute: lacute,
|
7023 | laemptyv: laemptyv,
|
7024 | lagran: lagran,
|
7025 | lambda: lambda,
|
7026 | lang: lang,
|
7027 | langd: langd,
|
7028 | langle: langle,
|
7029 | lap: lap,
|
7030 | laqu: laqu,
|
7031 | laquo: laquo,
|
7032 | larr: larr,
|
7033 | larrb: larrb,
|
7034 | larrbfs: larrbfs,
|
7035 | larrfs: larrfs,
|
7036 | larrhk: larrhk,
|
7037 | larrlp: larrlp,
|
7038 | larrpl: larrpl,
|
7039 | larrsim: larrsim,
|
7040 | larrtl: larrtl,
|
7041 | lat: lat,
|
7042 | latail: latail,
|
7043 | late: late,
|
7044 | lates: lates,
|
7045 | lbarr: lbarr,
|
7046 | lbbrk: lbbrk,
|
7047 | lbrace: lbrace,
|
7048 | lbrack: lbrack,
|
7049 | lbrke: lbrke,
|
7050 | lbrksld: lbrksld,
|
7051 | lbrkslu: lbrkslu,
|
7052 | lcaron: lcaron,
|
7053 | lcedil: lcedil,
|
7054 | lceil: lceil,
|
7055 | lcub: lcub,
|
7056 | lcy: lcy,
|
7057 | ldca: ldca,
|
7058 | ldquo: ldquo,
|
7059 | ldquor: ldquor,
|
7060 | ldrdhar: ldrdhar,
|
7061 | ldrushar: ldrushar,
|
7062 | ldsh: ldsh,
|
7063 | le: le,
|
7064 | leftarrow: leftarrow,
|
7065 | leftarrowtail: leftarrowtail,
|
7066 | leftharpoondown: leftharpoondown,
|
7067 | leftharpoonup: leftharpoonup,
|
7068 | leftleftarrows: leftleftarrows,
|
7069 | leftrightarrow: leftrightarrow,
|
7070 | leftrightarrows: leftrightarrows,
|
7071 | leftrightharpoons: leftrightharpoons,
|
7072 | leftrightsquigarrow: leftrightsquigarrow,
|
7073 | leftthreetimes: leftthreetimes,
|
7074 | leg: leg,
|
7075 | leq: leq,
|
7076 | leqq: leqq,
|
7077 | leqslant: leqslant,
|
7078 | les: les,
|
7079 | lescc: lescc,
|
7080 | lesdot: lesdot,
|
7081 | lesdoto: lesdoto,
|
7082 | lesdotor: lesdotor,
|
7083 | lesg: lesg,
|
7084 | lesges: lesges,
|
7085 | lessapprox: lessapprox,
|
7086 | lessdot: lessdot,
|
7087 | lesseqgtr: lesseqgtr,
|
7088 | lesseqqgtr: lesseqqgtr,
|
7089 | lessgtr: lessgtr,
|
7090 | lesssim: lesssim,
|
7091 | lfisht: lfisht,
|
7092 | lfloor: lfloor,
|
7093 | lfr: lfr,
|
7094 | lg: lg,
|
7095 | lgE: lgE,
|
7096 | lhard: lhard,
|
7097 | lharu: lharu,
|
7098 | lharul: lharul,
|
7099 | lhblk: lhblk,
|
7100 | ljcy: ljcy,
|
7101 | ll: ll,
|
7102 | llarr: llarr,
|
7103 | llcorner: llcorner,
|
7104 | llhard: llhard,
|
7105 | lltri: lltri,
|
7106 | lmidot: lmidot,
|
7107 | lmoust: lmoust,
|
7108 | lmoustache: lmoustache,
|
7109 | lnE: lnE,
|
7110 | lnap: lnap,
|
7111 | lnapprox: lnapprox,
|
7112 | lne: lne,
|
7113 | lneq: lneq,
|
7114 | lneqq: lneqq,
|
7115 | lnsim: lnsim,
|
7116 | loang: loang,
|
7117 | loarr: loarr,
|
7118 | lobrk: lobrk,
|
7119 | longleftarrow: longleftarrow,
|
7120 | longleftrightarrow: longleftrightarrow,
|
7121 | longmapsto: longmapsto,
|
7122 | longrightarrow: longrightarrow,
|
7123 | looparrowleft: looparrowleft,
|
7124 | looparrowright: looparrowright,
|
7125 | lopar: lopar,
|
7126 | lopf: lopf,
|
7127 | loplus: loplus,
|
7128 | lotimes: lotimes,
|
7129 | lowast: lowast,
|
7130 | lowbar: lowbar,
|
7131 | loz: loz,
|
7132 | lozenge: lozenge,
|
7133 | lozf: lozf,
|
7134 | lpar: lpar,
|
7135 | lparlt: lparlt,
|
7136 | lrarr: lrarr,
|
7137 | lrcorner: lrcorner,
|
7138 | lrhar: lrhar,
|
7139 | lrhard: lrhard,
|
7140 | lrm: lrm,
|
7141 | lrtri: lrtri,
|
7142 | lsaquo: lsaquo,
|
7143 | lscr: lscr,
|
7144 | lsh: lsh,
|
7145 | lsim: lsim,
|
7146 | lsime: lsime,
|
7147 | lsimg: lsimg,
|
7148 | lsqb: lsqb,
|
7149 | lsquo: lsquo,
|
7150 | lsquor: lsquor,
|
7151 | lstrok: lstrok,
|
7152 | l: l,
|
7153 | lt: lt,
|
7154 | ltcc: ltcc,
|
7155 | ltcir: ltcir,
|
7156 | ltdot: ltdot,
|
7157 | lthree: lthree,
|
7158 | ltimes: ltimes,
|
7159 | ltlarr: ltlarr,
|
7160 | ltquest: ltquest,
|
7161 | ltrPar: ltrPar,
|
7162 | ltri: ltri,
|
7163 | ltrie: ltrie,
|
7164 | ltrif: ltrif,
|
7165 | lurdshar: lurdshar,
|
7166 | luruhar: luruhar,
|
7167 | lvertneqq: lvertneqq,
|
7168 | lvnE: lvnE,
|
7169 | mDDot: mDDot,
|
7170 | mac: mac,
|
7171 | macr: macr,
|
7172 | male: male,
|
7173 | malt: malt,
|
7174 | maltese: maltese,
|
7175 | map: map,
|
7176 | mapsto: mapsto,
|
7177 | mapstodown: mapstodown,
|
7178 | mapstoleft: mapstoleft,
|
7179 | mapstoup: mapstoup,
|
7180 | marker: marker,
|
7181 | mcomma: mcomma,
|
7182 | mcy: mcy,
|
7183 | mdash: mdash,
|
7184 | measuredangle: measuredangle,
|
7185 | mfr: mfr,
|
7186 | mho: mho,
|
7187 | micr: micr,
|
7188 | micro: micro,
|
7189 | mid: mid,
|
7190 | midast: midast,
|
7191 | midcir: midcir,
|
7192 | middo: middo,
|
7193 | middot: middot,
|
7194 | minus: minus,
|
7195 | minusb: minusb,
|
7196 | minusd: minusd,
|
7197 | minusdu: minusdu,
|
7198 | mlcp: mlcp,
|
7199 | mldr: mldr,
|
7200 | mnplus: mnplus,
|
7201 | models: models,
|
7202 | mopf: mopf,
|
7203 | mp: mp,
|
7204 | mscr: mscr,
|
7205 | mstpos: mstpos,
|
7206 | mu: mu,
|
7207 | multimap: multimap,
|
7208 | mumap: mumap,
|
7209 | nGg: nGg,
|
7210 | nGt: nGt,
|
7211 | nGtv: nGtv,
|
7212 | nLeftarrow: nLeftarrow,
|
7213 | nLeftrightarrow: nLeftrightarrow,
|
7214 | nLl: nLl,
|
7215 | nLt: nLt,
|
7216 | nLtv: nLtv,
|
7217 | nRightarrow: nRightarrow,
|
7218 | nVDash: nVDash,
|
7219 | nVdash: nVdash,
|
7220 | nabla: nabla,
|
7221 | nacute: nacute,
|
7222 | nang: nang,
|
7223 | nap: nap,
|
7224 | napE: napE,
|
7225 | napid: napid,
|
7226 | napos: napos,
|
7227 | napprox: napprox,
|
7228 | natur: natur,
|
7229 | natural: natural,
|
7230 | naturals: naturals,
|
7231 | nbs: nbs,
|
7232 | nbsp: nbsp,
|
7233 | nbump: nbump,
|
7234 | nbumpe: nbumpe,
|
7235 | ncap: ncap,
|
7236 | ncaron: ncaron,
|
7237 | ncedil: ncedil,
|
7238 | ncong: ncong,
|
7239 | ncongdot: ncongdot,
|
7240 | ncup: ncup,
|
7241 | ncy: ncy,
|
7242 | ndash: ndash,
|
7243 | ne: ne,
|
7244 | neArr: neArr,
|
7245 | nearhk: nearhk,
|
7246 | nearr: nearr,
|
7247 | nearrow: nearrow,
|
7248 | nedot: nedot,
|
7249 | nequiv: nequiv,
|
7250 | nesear: nesear,
|
7251 | nesim: nesim,
|
7252 | nexist: nexist,
|
7253 | nexists: nexists,
|
7254 | nfr: nfr,
|
7255 | ngE: ngE,
|
7256 | nge: nge,
|
7257 | ngeq: ngeq,
|
7258 | ngeqq: ngeqq,
|
7259 | ngeqslant: ngeqslant,
|
7260 | nges: nges,
|
7261 | ngsim: ngsim,
|
7262 | ngt: ngt,
|
7263 | ngtr: ngtr,
|
7264 | nhArr: nhArr,
|
7265 | nharr: nharr,
|
7266 | nhpar: nhpar,
|
7267 | ni: ni,
|
7268 | nis: nis,
|
7269 | nisd: nisd,
|
7270 | niv: niv,
|
7271 | njcy: njcy,
|
7272 | nlArr: nlArr,
|
7273 | nlE: nlE,
|
7274 | nlarr: nlarr,
|
7275 | nldr: nldr,
|
7276 | nle: nle,
|
7277 | nleftarrow: nleftarrow,
|
7278 | nleftrightarrow: nleftrightarrow,
|
7279 | nleq: nleq,
|
7280 | nleqq: nleqq,
|
7281 | nleqslant: nleqslant,
|
7282 | nles: nles,
|
7283 | nless: nless,
|
7284 | nlsim: nlsim,
|
7285 | nlt: nlt,
|
7286 | nltri: nltri,
|
7287 | nltrie: nltrie,
|
7288 | nmid: nmid,
|
7289 | nopf: nopf,
|
7290 | no: no,
|
7291 | not: not,
|
7292 | notin: notin,
|
7293 | notinE: notinE,
|
7294 | notindot: notindot,
|
7295 | notinva: notinva,
|
7296 | notinvb: notinvb,
|
7297 | notinvc: notinvc,
|
7298 | notni: notni,
|
7299 | notniva: notniva,
|
7300 | notnivb: notnivb,
|
7301 | notnivc: notnivc,
|
7302 | npar: npar,
|
7303 | nparallel: nparallel,
|
7304 | nparsl: nparsl,
|
7305 | npart: npart,
|
7306 | npolint: npolint,
|
7307 | npr: npr,
|
7308 | nprcue: nprcue,
|
7309 | npre: npre,
|
7310 | nprec: nprec,
|
7311 | npreceq: npreceq,
|
7312 | nrArr: nrArr,
|
7313 | nrarr: nrarr,
|
7314 | nrarrc: nrarrc,
|
7315 | nrarrw: nrarrw,
|
7316 | nrightarrow: nrightarrow,
|
7317 | nrtri: nrtri,
|
7318 | nrtrie: nrtrie,
|
7319 | nsc: nsc,
|
7320 | nsccue: nsccue,
|
7321 | nsce: nsce,
|
7322 | nscr: nscr,
|
7323 | nshortmid: nshortmid,
|
7324 | nshortparallel: nshortparallel,
|
7325 | nsim: nsim,
|
7326 | nsime: nsime,
|
7327 | nsimeq: nsimeq,
|
7328 | nsmid: nsmid,
|
7329 | nspar: nspar,
|
7330 | nsqsube: nsqsube,
|
7331 | nsqsupe: nsqsupe,
|
7332 | nsub: nsub,
|
7333 | nsubE: nsubE,
|
7334 | nsube: nsube,
|
7335 | nsubset: nsubset,
|
7336 | nsubseteq: nsubseteq,
|
7337 | nsubseteqq: nsubseteqq,
|
7338 | nsucc: nsucc,
|
7339 | nsucceq: nsucceq,
|
7340 | nsup: nsup,
|
7341 | nsupE: nsupE,
|
7342 | nsupe: nsupe,
|
7343 | nsupset: nsupset,
|
7344 | nsupseteq: nsupseteq,
|
7345 | nsupseteqq: nsupseteqq,
|
7346 | ntgl: ntgl,
|
7347 | ntild: ntild,
|
7348 | ntilde: ntilde,
|
7349 | ntlg: ntlg,
|
7350 | ntriangleleft: ntriangleleft,
|
7351 | ntrianglelefteq: ntrianglelefteq,
|
7352 | ntriangleright: ntriangleright,
|
7353 | ntrianglerighteq: ntrianglerighteq,
|
7354 | nu: nu,
|
7355 | num: num,
|
7356 | numero: numero,
|
7357 | numsp: numsp,
|
7358 | nvDash: nvDash,
|
7359 | nvHarr: nvHarr,
|
7360 | nvap: nvap,
|
7361 | nvdash: nvdash,
|
7362 | nvge: nvge,
|
7363 | nvgt: nvgt,
|
7364 | nvinfin: nvinfin,
|
7365 | nvlArr: nvlArr,
|
7366 | nvle: nvle,
|
7367 | nvlt: nvlt,
|
7368 | nvltrie: nvltrie,
|
7369 | nvrArr: nvrArr,
|
7370 | nvrtrie: nvrtrie,
|
7371 | nvsim: nvsim,
|
7372 | nwArr: nwArr,
|
7373 | nwarhk: nwarhk,
|
7374 | nwarr: nwarr,
|
7375 | nwarrow: nwarrow,
|
7376 | nwnear: nwnear,
|
7377 | oS: oS,
|
7378 | oacut: oacut,
|
7379 | oacute: oacute,
|
7380 | oast: oast,
|
7381 | ocir: ocir,
|
7382 | ocirc: ocirc,
|
7383 | ocy: ocy,
|
7384 | odash: odash,
|
7385 | odblac: odblac,
|
7386 | odiv: odiv,
|
7387 | odot: odot,
|
7388 | odsold: odsold,
|
7389 | oelig: oelig,
|
7390 | ofcir: ofcir,
|
7391 | ofr: ofr,
|
7392 | ogon: ogon,
|
7393 | ograv: ograv,
|
7394 | ograve: ograve,
|
7395 | ogt: ogt,
|
7396 | ohbar: ohbar,
|
7397 | ohm: ohm,
|
7398 | oint: oint,
|
7399 | olarr: olarr,
|
7400 | olcir: olcir,
|
7401 | olcross: olcross,
|
7402 | oline: oline,
|
7403 | olt: olt,
|
7404 | omacr: omacr,
|
7405 | omega: omega,
|
7406 | omicron: omicron,
|
7407 | omid: omid,
|
7408 | ominus: ominus,
|
7409 | oopf: oopf,
|
7410 | opar: opar,
|
7411 | operp: operp,
|
7412 | oplus: oplus,
|
7413 | or: or,
|
7414 | orarr: orarr,
|
7415 | ord: ord,
|
7416 | order: order,
|
7417 | orderof: orderof,
|
7418 | ordf: ordf,
|
7419 | ordm: ordm,
|
7420 | origof: origof,
|
7421 | oror: oror,
|
7422 | orslope: orslope,
|
7423 | orv: orv,
|
7424 | oscr: oscr,
|
7425 | oslas: oslas,
|
7426 | oslash: oslash,
|
7427 | osol: osol,
|
7428 | otild: otild,
|
7429 | otilde: otilde,
|
7430 | otimes: otimes,
|
7431 | otimesas: otimesas,
|
7432 | oum: oum,
|
7433 | ouml: ouml,
|
7434 | ovbar: ovbar,
|
7435 | par: par,
|
7436 | para: para,
|
7437 | parallel: parallel,
|
7438 | parsim: parsim,
|
7439 | parsl: parsl,
|
7440 | part: part,
|
7441 | pcy: pcy,
|
7442 | percnt: percnt,
|
7443 | period: period,
|
7444 | permil: permil,
|
7445 | perp: perp,
|
7446 | pertenk: pertenk,
|
7447 | pfr: pfr,
|
7448 | phi: phi,
|
7449 | phiv: phiv,
|
7450 | phmmat: phmmat,
|
7451 | phone: phone,
|
7452 | pi: pi,
|
7453 | pitchfork: pitchfork,
|
7454 | piv: piv,
|
7455 | planck: planck,
|
7456 | planckh: planckh,
|
7457 | plankv: plankv,
|
7458 | plus: plus,
|
7459 | plusacir: plusacir,
|
7460 | plusb: plusb,
|
7461 | pluscir: pluscir,
|
7462 | plusdo: plusdo,
|
7463 | plusdu: plusdu,
|
7464 | pluse: pluse,
|
7465 | plusm: plusm,
|
7466 | plusmn: plusmn,
|
7467 | plussim: plussim,
|
7468 | plustwo: plustwo,
|
7469 | pm: pm,
|
7470 | pointint: pointint,
|
7471 | popf: popf,
|
7472 | poun: poun,
|
7473 | pound: pound,
|
7474 | pr: pr,
|
7475 | prE: prE,
|
7476 | prap: prap,
|
7477 | prcue: prcue,
|
7478 | pre: pre,
|
7479 | prec: prec,
|
7480 | precapprox: precapprox,
|
7481 | preccurlyeq: preccurlyeq,
|
7482 | preceq: preceq,
|
7483 | precnapprox: precnapprox,
|
7484 | precneqq: precneqq,
|
7485 | precnsim: precnsim,
|
7486 | precsim: precsim,
|
7487 | prime: prime,
|
7488 | primes: primes,
|
7489 | prnE: prnE,
|
7490 | prnap: prnap,
|
7491 | prnsim: prnsim,
|
7492 | prod: prod,
|
7493 | profalar: profalar,
|
7494 | profline: profline,
|
7495 | profsurf: profsurf,
|
7496 | prop: prop,
|
7497 | propto: propto,
|
7498 | prsim: prsim,
|
7499 | prurel: prurel,
|
7500 | pscr: pscr,
|
7501 | psi: psi,
|
7502 | puncsp: puncsp,
|
7503 | qfr: qfr,
|
7504 | qint: qint,
|
7505 | qopf: qopf,
|
7506 | qprime: qprime,
|
7507 | qscr: qscr,
|
7508 | quaternions: quaternions,
|
7509 | quatint: quatint,
|
7510 | quest: quest,
|
7511 | questeq: questeq,
|
7512 | quo: quo,
|
7513 | quot: quot,
|
7514 | rAarr: rAarr,
|
7515 | rArr: rArr,
|
7516 | rAtail: rAtail,
|
7517 | rBarr: rBarr,
|
7518 | rHar: rHar,
|
7519 | race: race,
|
7520 | racute: racute,
|
7521 | radic: radic,
|
7522 | raemptyv: raemptyv,
|
7523 | rang: rang,
|
7524 | rangd: rangd,
|
7525 | range: range,
|
7526 | rangle: rangle,
|
7527 | raqu: raqu,
|
7528 | raquo: raquo,
|
7529 | rarr: rarr,
|
7530 | rarrap: rarrap,
|
7531 | rarrb: rarrb,
|
7532 | rarrbfs: rarrbfs,
|
7533 | rarrc: rarrc,
|
7534 | rarrfs: rarrfs,
|
7535 | rarrhk: rarrhk,
|
7536 | rarrlp: rarrlp,
|
7537 | rarrpl: rarrpl,
|
7538 | rarrsim: rarrsim,
|
7539 | rarrtl: rarrtl,
|
7540 | rarrw: rarrw,
|
7541 | ratail: ratail,
|
7542 | ratio: ratio,
|
7543 | rationals: rationals,
|
7544 | rbarr: rbarr,
|
7545 | rbbrk: rbbrk,
|
7546 | rbrace: rbrace,
|
7547 | rbrack: rbrack,
|
7548 | rbrke: rbrke,
|
7549 | rbrksld: rbrksld,
|
7550 | rbrkslu: rbrkslu,
|
7551 | rcaron: rcaron,
|
7552 | rcedil: rcedil,
|
7553 | rceil: rceil,
|
7554 | rcub: rcub,
|
7555 | rcy: rcy,
|
7556 | rdca: rdca,
|
7557 | rdldhar: rdldhar,
|
7558 | rdquo: rdquo,
|
7559 | rdquor: rdquor,
|
7560 | rdsh: rdsh,
|
7561 | real: real,
|
7562 | realine: realine,
|
7563 | realpart: realpart,
|
7564 | reals: reals,
|
7565 | rect: rect,
|
7566 | re: re,
|
7567 | reg: reg,
|
7568 | rfisht: rfisht,
|
7569 | rfloor: rfloor,
|
7570 | rfr: rfr,
|
7571 | rhard: rhard,
|
7572 | rharu: rharu,
|
7573 | rharul: rharul,
|
7574 | rho: rho,
|
7575 | rhov: rhov,
|
7576 | rightarrow: rightarrow,
|
7577 | rightarrowtail: rightarrowtail,
|
7578 | rightharpoondown: rightharpoondown,
|
7579 | rightharpoonup: rightharpoonup,
|
7580 | rightleftarrows: rightleftarrows,
|
7581 | rightleftharpoons: rightleftharpoons,
|
7582 | rightrightarrows: rightrightarrows,
|
7583 | rightsquigarrow: rightsquigarrow,
|
7584 | rightthreetimes: rightthreetimes,
|
7585 | ring: ring,
|
7586 | risingdotseq: risingdotseq,
|
7587 | rlarr: rlarr,
|
7588 | rlhar: rlhar,
|
7589 | rlm: rlm,
|
7590 | rmoust: rmoust,
|
7591 | rmoustache: rmoustache,
|
7592 | rnmid: rnmid,
|
7593 | roang: roang,
|
7594 | roarr: roarr,
|
7595 | robrk: robrk,
|
7596 | ropar: ropar,
|
7597 | ropf: ropf,
|
7598 | roplus: roplus,
|
7599 | rotimes: rotimes,
|
7600 | rpar: rpar,
|
7601 | rpargt: rpargt,
|
7602 | rppolint: rppolint,
|
7603 | rrarr: rrarr,
|
7604 | rsaquo: rsaquo,
|
7605 | rscr: rscr,
|
7606 | rsh: rsh,
|
7607 | rsqb: rsqb,
|
7608 | rsquo: rsquo,
|
7609 | rsquor: rsquor,
|
7610 | rthree: rthree,
|
7611 | rtimes: rtimes,
|
7612 | rtri: rtri,
|
7613 | rtrie: rtrie,
|
7614 | rtrif: rtrif,
|
7615 | rtriltri: rtriltri,
|
7616 | ruluhar: ruluhar,
|
7617 | rx: rx,
|
7618 | sacute: sacute,
|
7619 | sbquo: sbquo,
|
7620 | sc: sc,
|
7621 | scE: scE,
|
7622 | scap: scap,
|
7623 | scaron: scaron,
|
7624 | sccue: sccue,
|
7625 | sce: sce,
|
7626 | scedil: scedil,
|
7627 | scirc: scirc,
|
7628 | scnE: scnE,
|
7629 | scnap: scnap,
|
7630 | scnsim: scnsim,
|
7631 | scpolint: scpolint,
|
7632 | scsim: scsim,
|
7633 | scy: scy,
|
7634 | sdot: sdot,
|
7635 | sdotb: sdotb,
|
7636 | sdote: sdote,
|
7637 | seArr: seArr,
|
7638 | searhk: searhk,
|
7639 | searr: searr,
|
7640 | searrow: searrow,
|
7641 | sec: sec,
|
7642 | sect: sect,
|
7643 | semi: semi,
|
7644 | seswar: seswar,
|
7645 | setminus: setminus,
|
7646 | setmn: setmn,
|
7647 | sext: sext,
|
7648 | sfr: sfr,
|
7649 | sfrown: sfrown,
|
7650 | sharp: sharp,
|
7651 | shchcy: shchcy,
|
7652 | shcy: shcy,
|
7653 | shortmid: shortmid,
|
7654 | shortparallel: shortparallel,
|
7655 | sh: sh,
|
7656 | shy: shy,
|
7657 | sigma: sigma,
|
7658 | sigmaf: sigmaf,
|
7659 | sigmav: sigmav,
|
7660 | sim: sim,
|
7661 | simdot: simdot,
|
7662 | sime: sime,
|
7663 | simeq: simeq,
|
7664 | simg: simg,
|
7665 | simgE: simgE,
|
7666 | siml: siml,
|
7667 | simlE: simlE,
|
7668 | simne: simne,
|
7669 | simplus: simplus,
|
7670 | simrarr: simrarr,
|
7671 | slarr: slarr,
|
7672 | smallsetminus: smallsetminus,
|
7673 | smashp: smashp,
|
7674 | smeparsl: smeparsl,
|
7675 | smid: smid,
|
7676 | smile: smile,
|
7677 | smt: smt,
|
7678 | smte: smte,
|
7679 | smtes: smtes,
|
7680 | softcy: softcy,
|
7681 | sol: sol,
|
7682 | solb: solb,
|
7683 | solbar: solbar,
|
7684 | sopf: sopf,
|
7685 | spades: spades,
|
7686 | spadesuit: spadesuit,
|
7687 | spar: spar,
|
7688 | sqcap: sqcap,
|
7689 | sqcaps: sqcaps,
|
7690 | sqcup: sqcup,
|
7691 | sqcups: sqcups,
|
7692 | sqsub: sqsub,
|
7693 | sqsube: sqsube,
|
7694 | sqsubset: sqsubset,
|
7695 | sqsubseteq: sqsubseteq,
|
7696 | sqsup: sqsup,
|
7697 | sqsupe: sqsupe,
|
7698 | sqsupset: sqsupset,
|
7699 | sqsupseteq: sqsupseteq,
|
7700 | squ: squ,
|
7701 | square: square,
|
7702 | squarf: squarf,
|
7703 | squf: squf,
|
7704 | srarr: srarr,
|
7705 | sscr: sscr,
|
7706 | ssetmn: ssetmn,
|
7707 | ssmile: ssmile,
|
7708 | sstarf: sstarf,
|
7709 | star: star,
|
7710 | starf: starf,
|
7711 | straightepsilon: straightepsilon,
|
7712 | straightphi: straightphi,
|
7713 | strns: strns,
|
7714 | sub: sub,
|
7715 | subE: subE,
|
7716 | subdot: subdot,
|
7717 | sube: sube,
|
7718 | subedot: subedot,
|
7719 | submult: submult,
|
7720 | subnE: subnE,
|
7721 | subne: subne,
|
7722 | subplus: subplus,
|
7723 | subrarr: subrarr,
|
7724 | subset: subset,
|
7725 | subseteq: subseteq,
|
7726 | subseteqq: subseteqq,
|
7727 | subsetneq: subsetneq,
|
7728 | subsetneqq: subsetneqq,
|
7729 | subsim: subsim,
|
7730 | subsub: subsub,
|
7731 | subsup: subsup,
|
7732 | succ: succ,
|
7733 | succapprox: succapprox,
|
7734 | succcurlyeq: succcurlyeq,
|
7735 | succeq: succeq,
|
7736 | succnapprox: succnapprox,
|
7737 | succneqq: succneqq,
|
7738 | succnsim: succnsim,
|
7739 | succsim: succsim,
|
7740 | sum: sum,
|
7741 | sung: sung,
|
7742 | sup: sup,
|
7743 | sup1: sup1,
|
7744 | sup2: sup2,
|
7745 | sup3: sup3,
|
7746 | supE: supE,
|
7747 | supdot: supdot,
|
7748 | supdsub: supdsub,
|
7749 | supe: supe,
|
7750 | supedot: supedot,
|
7751 | suphsol: suphsol,
|
7752 | suphsub: suphsub,
|
7753 | suplarr: suplarr,
|
7754 | supmult: supmult,
|
7755 | supnE: supnE,
|
7756 | supne: supne,
|
7757 | supplus: supplus,
|
7758 | supset: supset,
|
7759 | supseteq: supseteq,
|
7760 | supseteqq: supseteqq,
|
7761 | supsetneq: supsetneq,
|
7762 | supsetneqq: supsetneqq,
|
7763 | supsim: supsim,
|
7764 | supsub: supsub,
|
7765 | supsup: supsup,
|
7766 | swArr: swArr,
|
7767 | swarhk: swarhk,
|
7768 | swarr: swarr,
|
7769 | swarrow: swarrow,
|
7770 | swnwar: swnwar,
|
7771 | szli: szli,
|
7772 | szlig: szlig,
|
7773 | target: target,
|
7774 | tau: tau,
|
7775 | tbrk: tbrk,
|
7776 | tcaron: tcaron,
|
7777 | tcedil: tcedil,
|
7778 | tcy: tcy,
|
7779 | tdot: tdot,
|
7780 | telrec: telrec,
|
7781 | tfr: tfr,
|
7782 | there4: there4,
|
7783 | therefore: therefore,
|
7784 | theta: theta,
|
7785 | thetasym: thetasym,
|
7786 | thetav: thetav,
|
7787 | thickapprox: thickapprox,
|
7788 | thicksim: thicksim,
|
7789 | thinsp: thinsp,
|
7790 | thkap: thkap,
|
7791 | thksim: thksim,
|
7792 | thor: thor,
|
7793 | thorn: thorn,
|
7794 | tilde: tilde,
|
7795 | time: time,
|
7796 | times: times,
|
7797 | timesb: timesb,
|
7798 | timesbar: timesbar,
|
7799 | timesd: timesd,
|
7800 | tint: tint,
|
7801 | toea: toea,
|
7802 | top: top,
|
7803 | topbot: topbot,
|
7804 | topcir: topcir,
|
7805 | topf: topf,
|
7806 | topfork: topfork,
|
7807 | tosa: tosa,
|
7808 | tprime: tprime,
|
7809 | trade: trade,
|
7810 | triangle: triangle,
|
7811 | triangledown: triangledown,
|
7812 | triangleleft: triangleleft,
|
7813 | trianglelefteq: trianglelefteq,
|
7814 | triangleq: triangleq,
|
7815 | triangleright: triangleright,
|
7816 | trianglerighteq: trianglerighteq,
|
7817 | tridot: tridot,
|
7818 | trie: trie,
|
7819 | triminus: triminus,
|
7820 | triplus: triplus,
|
7821 | trisb: trisb,
|
7822 | tritime: tritime,
|
7823 | trpezium: trpezium,
|
7824 | tscr: tscr,
|
7825 | tscy: tscy,
|
7826 | tshcy: tshcy,
|
7827 | tstrok: tstrok,
|
7828 | twixt: twixt,
|
7829 | twoheadleftarrow: twoheadleftarrow,
|
7830 | twoheadrightarrow: twoheadrightarrow,
|
7831 | uArr: uArr,
|
7832 | uHar: uHar,
|
7833 | uacut: uacut,
|
7834 | uacute: uacute,
|
7835 | uarr: uarr,
|
7836 | ubrcy: ubrcy,
|
7837 | ubreve: ubreve,
|
7838 | ucir: ucir,
|
7839 | ucirc: ucirc,
|
7840 | ucy: ucy,
|
7841 | udarr: udarr,
|
7842 | udblac: udblac,
|
7843 | udhar: udhar,
|
7844 | ufisht: ufisht,
|
7845 | ufr: ufr,
|
7846 | ugrav: ugrav,
|
7847 | ugrave: ugrave,
|
7848 | uharl: uharl,
|
7849 | uharr: uharr,
|
7850 | uhblk: uhblk,
|
7851 | ulcorn: ulcorn,
|
7852 | ulcorner: ulcorner,
|
7853 | ulcrop: ulcrop,
|
7854 | ultri: ultri,
|
7855 | umacr: umacr,
|
7856 | um: um,
|
7857 | uml: uml,
|
7858 | uogon: uogon,
|
7859 | uopf: uopf,
|
7860 | uparrow: uparrow,
|
7861 | updownarrow: updownarrow,
|
7862 | upharpoonleft: upharpoonleft,
|
7863 | upharpoonright: upharpoonright,
|
7864 | uplus: uplus,
|
7865 | upsi: upsi,
|
7866 | upsih: upsih,
|
7867 | upsilon: upsilon,
|
7868 | upuparrows: upuparrows,
|
7869 | urcorn: urcorn,
|
7870 | urcorner: urcorner,
|
7871 | urcrop: urcrop,
|
7872 | uring: uring,
|
7873 | urtri: urtri,
|
7874 | uscr: uscr,
|
7875 | utdot: utdot,
|
7876 | utilde: utilde,
|
7877 | utri: utri,
|
7878 | utrif: utrif,
|
7879 | uuarr: uuarr,
|
7880 | uum: uum,
|
7881 | uuml: uuml,
|
7882 | uwangle: uwangle,
|
7883 | vArr: vArr,
|
7884 | vBar: vBar,
|
7885 | vBarv: vBarv,
|
7886 | vDash: vDash,
|
7887 | vangrt: vangrt,
|
7888 | varepsilon: varepsilon,
|
7889 | varkappa: varkappa,
|
7890 | varnothing: varnothing,
|
7891 | varphi: varphi,
|
7892 | varpi: varpi,
|
7893 | varpropto: varpropto,
|
7894 | varr: varr,
|
7895 | varrho: varrho,
|
7896 | varsigma: varsigma,
|
7897 | varsubsetneq: varsubsetneq,
|
7898 | varsubsetneqq: varsubsetneqq,
|
7899 | varsupsetneq: varsupsetneq,
|
7900 | varsupsetneqq: varsupsetneqq,
|
7901 | vartheta: vartheta,
|
7902 | vartriangleleft: vartriangleleft,
|
7903 | vartriangleright: vartriangleright,
|
7904 | vcy: vcy,
|
7905 | vdash: vdash,
|
7906 | vee: vee,
|
7907 | veebar: veebar,
|
7908 | veeeq: veeeq,
|
7909 | vellip: vellip,
|
7910 | verbar: verbar,
|
7911 | vert: vert,
|
7912 | vfr: vfr,
|
7913 | vltri: vltri,
|
7914 | vnsub: vnsub,
|
7915 | vnsup: vnsup,
|
7916 | vopf: vopf,
|
7917 | vprop: vprop,
|
7918 | vrtri: vrtri,
|
7919 | vscr: vscr,
|
7920 | vsubnE: vsubnE,
|
7921 | vsubne: vsubne,
|
7922 | vsupnE: vsupnE,
|
7923 | vsupne: vsupne,
|
7924 | vzigzag: vzigzag,
|
7925 | wcirc: wcirc,
|
7926 | wedbar: wedbar,
|
7927 | wedge: wedge,
|
7928 | wedgeq: wedgeq,
|
7929 | weierp: weierp,
|
7930 | wfr: wfr,
|
7931 | wopf: wopf,
|
7932 | wp: wp,
|
7933 | wr: wr,
|
7934 | wreath: wreath,
|
7935 | wscr: wscr,
|
7936 | xcap: xcap,
|
7937 | xcirc: xcirc,
|
7938 | xcup: xcup,
|
7939 | xdtri: xdtri,
|
7940 | xfr: xfr,
|
7941 | xhArr: xhArr,
|
7942 | xharr: xharr,
|
7943 | xi: xi,
|
7944 | xlArr: xlArr,
|
7945 | xlarr: xlarr,
|
7946 | xmap: xmap,
|
7947 | xnis: xnis,
|
7948 | xodot: xodot,
|
7949 | xopf: xopf,
|
7950 | xoplus: xoplus,
|
7951 | xotime: xotime,
|
7952 | xrArr: xrArr,
|
7953 | xrarr: xrarr,
|
7954 | xscr: xscr,
|
7955 | xsqcup: xsqcup,
|
7956 | xuplus: xuplus,
|
7957 | xutri: xutri,
|
7958 | xvee: xvee,
|
7959 | xwedge: xwedge,
|
7960 | yacut: yacut,
|
7961 | yacute: yacute,
|
7962 | yacy: yacy,
|
7963 | ycirc: ycirc,
|
7964 | ycy: ycy,
|
7965 | ye: ye,
|
7966 | yen: yen,
|
7967 | yfr: yfr,
|
7968 | yicy: yicy,
|
7969 | yopf: yopf,
|
7970 | yscr: yscr,
|
7971 | yucy: yucy,
|
7972 | yum: yum,
|
7973 | yuml: yuml,
|
7974 | zacute: zacute,
|
7975 | zcaron: zcaron,
|
7976 | zcy: zcy,
|
7977 | zdot: zdot,
|
7978 | zeetrf: zeetrf,
|
7979 | zeta: zeta,
|
7980 | zfr: zfr,
|
7981 | zhcy: zhcy,
|
7982 | zigrarr: zigrarr,
|
7983 | zopf: zopf,
|
7984 | zscr: zscr,
|
7985 | zwj: zwj,
|
7986 | zwnj: zwnj
|
7987 | };
|
7988 | var characterEntities = require$$0;
|
7989 | var decodeEntity_1 = decodeEntity$1;
|
7990 | var own$2 = {}.hasOwnProperty;
|
7991 |
|
7992 | function decodeEntity$1(characters) {
|
7993 | return own$2.call(characterEntities, characters) ? characterEntities[characters] : false;
|
7994 | }
|
7995 |
|
7996 | var legacy = require$$0$1;
|
7997 | var invalid = require$$1;
|
7998 | var decimal = isDecimal;
|
7999 | var hexadecimal = isHexadecimal;
|
8000 | var alphanumerical = isAlphanumerical;
|
8001 | var decodeEntity = decodeEntity_1;
|
8002 | var parseEntities_1 = parseEntities;
|
8003 | var own$1 = {}.hasOwnProperty;
|
8004 | var fromCharCode = String.fromCharCode;
|
8005 | var noop = Function.prototype;
|
8006 |
|
8007 | var defaults = {
|
8008 | warning: null,
|
8009 | reference: null,
|
8010 | text: null,
|
8011 | warningContext: null,
|
8012 | referenceContext: null,
|
8013 | textContext: null,
|
8014 | position: {},
|
8015 | additional: null,
|
8016 | attribute: false,
|
8017 | nonTerminated: true
|
8018 | };
|
8019 |
|
8020 | var tab = 9;
|
8021 |
|
8022 | var lineFeed = 10;
|
8023 |
|
8024 | var formFeed = 12;
|
8025 |
|
8026 | var space = 32;
|
8027 |
|
8028 | var ampersand = 38;
|
8029 |
|
8030 | var semicolon = 59;
|
8031 |
|
8032 | var lessThan = 60;
|
8033 |
|
8034 | var equalsTo = 61;
|
8035 |
|
8036 | var numberSign = 35;
|
8037 |
|
8038 | var uppercaseX = 88;
|
8039 |
|
8040 | var lowercaseX = 120;
|
8041 |
|
8042 | var replacementCharacter = 65533;
|
8043 |
|
8044 |
|
8045 | var name = 'named';
|
8046 | var hexa = 'hexadecimal';
|
8047 | var deci = 'decimal';
|
8048 |
|
8049 | var bases = {};
|
8050 | bases[hexa] = 16;
|
8051 | bases[deci] = 10;
|
8052 |
|
8053 |
|
8054 |
|
8055 |
|
8056 | var tests = {};
|
8057 | tests[name] = alphanumerical;
|
8058 | tests[deci] = decimal;
|
8059 | tests[hexa] = hexadecimal;
|
8060 |
|
8061 | var namedNotTerminated = 1;
|
8062 | var numericNotTerminated = 2;
|
8063 | var namedEmpty = 3;
|
8064 | var numericEmpty = 4;
|
8065 | var namedUnknown = 5;
|
8066 | var numericDisallowed = 6;
|
8067 | var numericProhibited = 7;
|
8068 |
|
8069 | var messages = {};
|
8070 | messages[namedNotTerminated] = 'Named character references must be terminated by a semicolon';
|
8071 | messages[numericNotTerminated] = 'Numeric character references must be terminated by a semicolon';
|
8072 | messages[namedEmpty] = 'Named character references cannot be empty';
|
8073 | messages[numericEmpty] = 'Numeric character references cannot be empty';
|
8074 | messages[namedUnknown] = 'Named character references must be known';
|
8075 | messages[numericDisallowed] = 'Numeric character references cannot be disallowed';
|
8076 | messages[numericProhibited] = 'Numeric character references cannot be outside the permissible Unicode range';
|
8077 |
|
8078 | function parseEntities(value, options) {
|
8079 | var settings = {};
|
8080 | var option;
|
8081 | var key;
|
8082 |
|
8083 | if (!options) {
|
8084 | options = {};
|
8085 | }
|
8086 |
|
8087 | for (key in defaults) {
|
8088 | option = options[key];
|
8089 | settings[key] = option === null || option === undefined ? defaults[key] : option;
|
8090 | }
|
8091 |
|
8092 | if (settings.position.indent || settings.position.start) {
|
8093 | settings.indent = settings.position.indent || [];
|
8094 | settings.position = settings.position.start;
|
8095 | }
|
8096 |
|
8097 | return parse(value, settings);
|
8098 | }
|
8099 |
|
8100 |
|
8101 |
|
8102 | function parse(value, settings) {
|
8103 | var additional = settings.additional;
|
8104 | var nonTerminated = settings.nonTerminated;
|
8105 | var handleText = settings.text;
|
8106 | var handleReference = settings.reference;
|
8107 | var handleWarning = settings.warning;
|
8108 | var textContext = settings.textContext;
|
8109 | var referenceContext = settings.referenceContext;
|
8110 | var warningContext = settings.warningContext;
|
8111 | var pos = settings.position;
|
8112 | var indent = settings.indent || [];
|
8113 | var length = value.length;
|
8114 | var index = 0;
|
8115 | var lines = -1;
|
8116 | var column = pos.column || 1;
|
8117 | var line = pos.line || 1;
|
8118 | var queue = '';
|
8119 | var result = [];
|
8120 | var entityCharacters;
|
8121 | var namedEntity;
|
8122 | var terminated;
|
8123 | var characters;
|
8124 | var character;
|
8125 | var reference;
|
8126 | var following;
|
8127 | var warning;
|
8128 | var reason;
|
8129 | var output;
|
8130 | var entity;
|
8131 | var begin;
|
8132 | var start;
|
8133 | var type;
|
8134 | var test;
|
8135 | var prev;
|
8136 | var next;
|
8137 | var diff;
|
8138 | var end;
|
8139 |
|
8140 | if (typeof additional === 'string') {
|
8141 | additional = additional.charCodeAt(0);
|
8142 | }
|
8143 |
|
8144 |
|
8145 | prev = now();
|
8146 |
|
8147 | warning = handleWarning ? parseError : noop;
|
8148 |
|
8149 |
|
8150 | index--;
|
8151 | length++;
|
8152 |
|
8153 | while (++index < length) {
|
8154 |
|
8155 | if (character === lineFeed) {
|
8156 | column = indent[lines] || 1;
|
8157 | }
|
8158 |
|
8159 | character = value.charCodeAt(index);
|
8160 |
|
8161 | if (character === ampersand) {
|
8162 | following = value.charCodeAt(index + 1);
|
8163 |
|
8164 | if (following === tab || following === lineFeed || following === formFeed || following === space || following === ampersand || following === lessThan || following !== following || additional && following === additional) {
|
8165 |
|
8166 |
|
8167 |
|
8168 | queue += fromCharCode(character);
|
8169 | column++;
|
8170 | continue;
|
8171 | }
|
8172 |
|
8173 | start = index + 1;
|
8174 | begin = start;
|
8175 | end = start;
|
8176 |
|
8177 | if (following === numberSign) {
|
8178 |
|
8179 | end = ++begin;
|
8180 |
|
8181 | following = value.charCodeAt(end);
|
8182 |
|
8183 | if (following === uppercaseX || following === lowercaseX) {
|
8184 |
|
8185 | type = hexa;
|
8186 | end = ++begin;
|
8187 | } else {
|
8188 |
|
8189 | type = deci;
|
8190 | }
|
8191 | } else {
|
8192 |
|
8193 | type = name;
|
8194 | }
|
8195 |
|
8196 | entityCharacters = '';
|
8197 | entity = '';
|
8198 | characters = '';
|
8199 | test = tests[type];
|
8200 | end--;
|
8201 |
|
8202 | while (++end < length) {
|
8203 | following = value.charCodeAt(end);
|
8204 |
|
8205 | if (!test(following)) {
|
8206 | break;
|
8207 | }
|
8208 |
|
8209 | characters += fromCharCode(following);
|
8210 |
|
8211 |
|
8212 |
|
8213 | if (type === name && own$1.call(legacy, characters)) {
|
8214 | entityCharacters = characters;
|
8215 | entity = legacy[characters];
|
8216 | }
|
8217 | }
|
8218 |
|
8219 | terminated = value.charCodeAt(end) === semicolon;
|
8220 |
|
8221 | if (terminated) {
|
8222 | end++;
|
8223 | namedEntity = type === name ? decodeEntity(characters) : false;
|
8224 |
|
8225 | if (namedEntity) {
|
8226 | entityCharacters = characters;
|
8227 | entity = namedEntity;
|
8228 | }
|
8229 | }
|
8230 |
|
8231 | diff = 1 + end - start;
|
8232 | if (!terminated && !nonTerminated) ;else if (!characters) {
|
8233 |
|
8234 |
|
8235 | if (type !== name) {
|
8236 | warning(numericEmpty, diff);
|
8237 | }
|
8238 | } else if (type === name) {
|
8239 |
|
8240 |
|
8241 | if (terminated && !entity) {
|
8242 | warning(namedUnknown, 1);
|
8243 | } else {
|
8244 |
|
8245 |
|
8246 | if (entityCharacters !== characters) {
|
8247 | end = begin + entityCharacters.length;
|
8248 | diff = 1 + end - begin;
|
8249 | terminated = false;
|
8250 | }
|
8251 |
|
8252 |
|
8253 | if (!terminated) {
|
8254 | reason = entityCharacters ? namedNotTerminated : namedEmpty;
|
8255 |
|
8256 | if (settings.attribute) {
|
8257 | following = value.charCodeAt(end);
|
8258 |
|
8259 | if (following === equalsTo) {
|
8260 | warning(reason, diff);
|
8261 | entity = null;
|
8262 | } else if (alphanumerical(following)) {
|
8263 | entity = null;
|
8264 | } else {
|
8265 | warning(reason, diff);
|
8266 | }
|
8267 | } else {
|
8268 | warning(reason, diff);
|
8269 | }
|
8270 | }
|
8271 | }
|
8272 |
|
8273 | reference = entity;
|
8274 | } else {
|
8275 | if (!terminated) {
|
8276 |
|
8277 |
|
8278 | warning(numericNotTerminated, diff);
|
8279 | }
|
8280 |
|
8281 |
|
8282 | reference = parseInt(characters, bases[type]);
|
8283 |
|
8284 |
|
8285 | if (prohibited(reference)) {
|
8286 | warning(numericProhibited, diff);
|
8287 | reference = fromCharCode(replacementCharacter);
|
8288 | } else if (reference in invalid) {
|
8289 |
|
8290 |
|
8291 | warning(numericDisallowed, diff);
|
8292 | reference = invalid[reference];
|
8293 | } else {
|
8294 |
|
8295 | output = '';
|
8296 |
|
8297 | if (disallowed(reference)) {
|
8298 | warning(numericDisallowed, diff);
|
8299 | }
|
8300 |
|
8301 |
|
8302 | if (reference > 0xffff) {
|
8303 | reference -= 0x10000;
|
8304 | output += fromCharCode(reference >>> (10 & 0x3ff) | 0xd800);
|
8305 | reference = 0xdc00 | reference & 0x3ff;
|
8306 | }
|
8307 |
|
8308 | reference = output + fromCharCode(reference);
|
8309 | }
|
8310 | }
|
8311 |
|
8312 |
|
8313 | if (reference) {
|
8314 | flush();
|
8315 | prev = now();
|
8316 | index = end - 1;
|
8317 | column += end - start + 1;
|
8318 | result.push(reference);
|
8319 | next = now();
|
8320 | next.offset++;
|
8321 |
|
8322 | if (handleReference) {
|
8323 | handleReference.call(referenceContext, reference, {
|
8324 | start: prev,
|
8325 | end: next
|
8326 | }, value.slice(start - 1, end));
|
8327 | }
|
8328 |
|
8329 | prev = next;
|
8330 | } else {
|
8331 |
|
8332 |
|
8333 |
|
8334 |
|
8335 | characters = value.slice(start - 1, end);
|
8336 | queue += characters;
|
8337 | column += characters.length;
|
8338 | index = end - 1;
|
8339 | }
|
8340 | } else {
|
8341 |
|
8342 | if (character === 10
|
8343 | ) {
|
8344 | line++;
|
8345 | lines++;
|
8346 | column = 0;
|
8347 | }
|
8348 |
|
8349 | if (character === character) {
|
8350 | queue += fromCharCode(character);
|
8351 | column++;
|
8352 | } else {
|
8353 | flush();
|
8354 | }
|
8355 | }
|
8356 | }
|
8357 |
|
8358 |
|
8359 | return result.join('');
|
8360 |
|
8361 | function now() {
|
8362 | return {
|
8363 | line: line,
|
8364 | column: column,
|
8365 | offset: index + (pos.offset || 0)
|
8366 | };
|
8367 | }
|
8368 |
|
8369 |
|
8370 | function parseError(code, offset) {
|
8371 | var position = now();
|
8372 | position.column += offset;
|
8373 | position.offset += offset;
|
8374 | handleWarning.call(warningContext, messages[code], position, code);
|
8375 | }
|
8376 |
|
8377 |
|
8378 |
|
8379 |
|
8380 | function flush() {
|
8381 | if (queue) {
|
8382 | result.push(queue);
|
8383 |
|
8384 | if (handleText) {
|
8385 | handleText.call(textContext, queue, {
|
8386 | start: prev,
|
8387 | end: now()
|
8388 | });
|
8389 | }
|
8390 |
|
8391 | queue = '';
|
8392 | }
|
8393 | }
|
8394 | }
|
8395 |
|
8396 |
|
8397 | function prohibited(code) {
|
8398 | return code >= 0xd800 && code <= 0xdfff || code > 0x10ffff;
|
8399 | }
|
8400 |
|
8401 |
|
8402 | function disallowed(code) {
|
8403 | return code >= 0x0001 && code <= 0x0008 || code === 0x000b || code >= 0x000d && code <= 0x001f || code >= 0x007f && code <= 0x009f || code >= 0xfdd0 && code <= 0xfdef || (code & 0xffff) === 0xffff || (code & 0xffff) === 0xfffe;
|
8404 | }
|
8405 |
|
8406 | var prismCore = {
|
8407 | exports: {}
|
8408 | };
|
8409 |
|
8410 | (function (module) {
|
8411 |
|
8412 | var _self = typeof window !== 'undefined' ? window
|
8413 | : typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self
|
8414 | : {}
|
8415 | ;
|
8416 | |
8417 |
|
8418 |
|
8419 |
|
8420 |
|
8421 |
|
8422 |
|
8423 |
|
8424 |
|
8425 |
|
8426 | var Prism = function (_self) {
|
8427 |
|
8428 | var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
|
8429 | var uniqueId = 0;
|
8430 |
|
8431 | var plainTextGrammar = {};
|
8432 | var _ = {
|
8433 | |
8434 |
|
8435 |
|
8436 |
|
8437 |
|
8438 |
|
8439 |
|
8440 |
|
8441 |
|
8442 |
|
8443 |
|
8444 |
|
8445 |
|
8446 |
|
8447 |
|
8448 |
|
8449 |
|
8450 |
|
8451 |
|
8452 |
|
8453 |
|
8454 | manual: _self.Prism && _self.Prism.manual,
|
8455 |
|
8456 | |
8457 |
|
8458 |
|
8459 |
|
8460 |
|
8461 |
|
8462 |
|
8463 |
|
8464 |
|
8465 |
|
8466 |
|
8467 |
|
8468 |
|
8469 |
|
8470 |
|
8471 |
|
8472 |
|
8473 |
|
8474 |
|
8475 |
|
8476 |
|
8477 | disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
|
8478 |
|
8479 | |
8480 |
|
8481 |
|
8482 |
|
8483 |
|
8484 |
|
8485 |
|
8486 |
|
8487 |
|
8488 | util: {
|
8489 | encode: function encode(tokens) {
|
8490 | if (tokens instanceof Token) {
|
8491 | return new Token(tokens.type, encode(tokens.content), tokens.alias);
|
8492 | } else if (Array.isArray(tokens)) {
|
8493 | return tokens.map(encode);
|
8494 | } else {
|
8495 | return tokens.replace(/&/g, '&').replace(/</g, '<').replace(/\u00a0/g, ' ');
|
8496 | }
|
8497 | },
|
8498 |
|
8499 | |
8500 |
|
8501 |
|
8502 |
|
8503 |
|
8504 |
|
8505 |
|
8506 |
|
8507 |
|
8508 |
|
8509 |
|
8510 |
|
8511 |
|
8512 |
|
8513 |
|
8514 |
|
8515 | type: function type(o) {
|
8516 | return Object.prototype.toString.call(o).slice(8, -1);
|
8517 | },
|
8518 |
|
8519 | |
8520 |
|
8521 |
|
8522 |
|
8523 |
|
8524 |
|
8525 | objId: function objId(obj) {
|
8526 | if (!obj['__id']) {
|
8527 | Object.defineProperty(obj, '__id', {
|
8528 | value: ++uniqueId
|
8529 | });
|
8530 | }
|
8531 |
|
8532 | return obj['__id'];
|
8533 | },
|
8534 |
|
8535 | |
8536 |
|
8537 |
|
8538 |
|
8539 |
|
8540 |
|
8541 |
|
8542 |
|
8543 |
|
8544 |
|
8545 | clone: function deepClone(o, visited) {
|
8546 | visited = visited || {};
|
8547 | var clone;
|
8548 | var id;
|
8549 |
|
8550 | switch (_.util.type(o)) {
|
8551 | case 'Object':
|
8552 | id = _.util.objId(o);
|
8553 |
|
8554 | if (visited[id]) {
|
8555 | return visited[id];
|
8556 | }
|
8557 |
|
8558 | clone =
|
8559 |
|
8560 | {};
|
8561 | visited[id] = clone;
|
8562 |
|
8563 | for (var key in o) {
|
8564 | if (o.hasOwnProperty(key)) {
|
8565 | clone[key] = deepClone(o[key], visited);
|
8566 | }
|
8567 | }
|
8568 |
|
8569 | return (
|
8570 |
|
8571 | clone
|
8572 | );
|
8573 |
|
8574 | case 'Array':
|
8575 | id = _.util.objId(o);
|
8576 |
|
8577 | if (visited[id]) {
|
8578 | return visited[id];
|
8579 | }
|
8580 |
|
8581 | clone = [];
|
8582 | visited[id] = clone;
|
8583 |
|
8584 |
|
8585 |
|
8586 |
|
8587 | o.forEach(function (v, i) {
|
8588 | clone[i] = deepClone(v, visited);
|
8589 | });
|
8590 | return (
|
8591 |
|
8592 | clone
|
8593 | );
|
8594 |
|
8595 | default:
|
8596 | return o;
|
8597 | }
|
8598 | },
|
8599 |
|
8600 | |
8601 |
|
8602 |
|
8603 |
|
8604 |
|
8605 |
|
8606 |
|
8607 |
|
8608 | getLanguage: function getLanguage(element) {
|
8609 | while (element) {
|
8610 | var m = lang.exec(element.className);
|
8611 |
|
8612 | if (m) {
|
8613 | return m[1].toLowerCase();
|
8614 | }
|
8615 |
|
8616 | element = element.parentElement;
|
8617 | }
|
8618 |
|
8619 | return 'none';
|
8620 | },
|
8621 |
|
8622 | |
8623 |
|
8624 |
|
8625 |
|
8626 |
|
8627 |
|
8628 |
|
8629 | setLanguage: function setLanguage(element, language) {
|
8630 |
|
8631 |
|
8632 | element.className = element.className.replace(RegExp(lang, 'gi'), '');
|
8633 |
|
8634 |
|
8635 | element.classList.add('language-' + language);
|
8636 | },
|
8637 |
|
8638 | |
8639 |
|
8640 |
|
8641 |
|
8642 |
|
8643 |
|
8644 |
|
8645 | currentScript: function currentScript() {
|
8646 | if (typeof document === 'undefined') {
|
8647 | return null;
|
8648 | }
|
8649 |
|
8650 | if ('currentScript' in document && 1 < 2
|
8651 |
|
8652 | ) {
|
8653 | return (
|
8654 |
|
8655 | document.currentScript
|
8656 | );
|
8657 | }
|
8658 |
|
8659 |
|
8660 |
|
8661 |
|
8662 | try {
|
8663 | throw new Error();
|
8664 | } catch (err) {
|
8665 |
|
8666 |
|
8667 |
|
8668 |
|
8669 |
|
8670 |
|
8671 | var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) || [])[1];
|
8672 |
|
8673 | if (src) {
|
8674 | var scripts = document.getElementsByTagName('script');
|
8675 |
|
8676 | for (var i in scripts) {
|
8677 | if (scripts[i].src == src) {
|
8678 | return scripts[i];
|
8679 | }
|
8680 | }
|
8681 | }
|
8682 |
|
8683 | return null;
|
8684 | }
|
8685 | },
|
8686 |
|
8687 | |
8688 |
|
8689 |
|
8690 |
|
8691 |
|
8692 |
|
8693 |
|
8694 |
|
8695 |
|
8696 |
|
8697 |
|
8698 |
|
8699 |
|
8700 |
|
8701 |
|
8702 |
|
8703 |
|
8704 |
|
8705 |
|
8706 | isActive: function isActive(element, className, defaultActivation) {
|
8707 | var no = 'no-' + className;
|
8708 |
|
8709 | while (element) {
|
8710 | var classList = element.classList;
|
8711 |
|
8712 | if (classList.contains(className)) {
|
8713 | return true;
|
8714 | }
|
8715 |
|
8716 | if (classList.contains(no)) {
|
8717 | return false;
|
8718 | }
|
8719 |
|
8720 | element = element.parentElement;
|
8721 | }
|
8722 |
|
8723 | return !!defaultActivation;
|
8724 | }
|
8725 | },
|
8726 |
|
8727 | |
8728 |
|
8729 |
|
8730 |
|
8731 |
|
8732 |
|
8733 |
|
8734 | languages: {
|
8735 | |
8736 |
|
8737 |
|
8738 | plain: plainTextGrammar,
|
8739 | plaintext: plainTextGrammar,
|
8740 | text: plainTextGrammar,
|
8741 | txt: plainTextGrammar,
|
8742 |
|
8743 | |
8744 |
|
8745 |
|
8746 |
|
8747 |
|
8748 |
|
8749 |
|
8750 |
|
8751 |
|
8752 |
|
8753 |
|
8754 |
|
8755 |
|
8756 |
|
8757 |
|
8758 |
|
8759 |
|
8760 |
|
8761 |
|
8762 |
|
8763 |
|
8764 |
|
8765 |
|
8766 |
|
8767 |
|
8768 |
|
8769 |
|
8770 |
|
8771 | extend: function extend(id, redef) {
|
8772 | var lang = _.util.clone(_.languages[id]);
|
8773 |
|
8774 | for (var key in redef) {
|
8775 | lang[key] = redef[key];
|
8776 | }
|
8777 |
|
8778 | return lang;
|
8779 | },
|
8780 |
|
8781 | |
8782 |
|
8783 |
|
8784 |
|
8785 |
|
8786 |
|
8787 |
|
8788 |
|
8789 |
|
8790 |
|
8791 |
|
8792 |
|
8793 |
|
8794 |
|
8795 |
|
8796 |
|
8797 |
|
8798 |
|
8799 |
|
8800 |
|
8801 |
|
8802 |
|
8803 |
|
8804 |
|
8805 |
|
8806 |
|
8807 |
|
8808 |
|
8809 |
|
8810 |
|
8811 |
|
8812 |
|
8813 |
|
8814 |
|
8815 |
|
8816 |
|
8817 |
|
8818 |
|
8819 |
|
8820 |
|
8821 |
|
8822 |
|
8823 |
|
8824 |
|
8825 |
|
8826 |
|
8827 |
|
8828 |
|
8829 |
|
8830 |
|
8831 |
|
8832 |
|
8833 |
|
8834 |
|
8835 |
|
8836 |
|
8837 |
|
8838 |
|
8839 |
|
8840 |
|
8841 |
|
8842 |
|
8843 |
|
8844 |
|
8845 |
|
8846 |
|
8847 |
|
8848 |
|
8849 |
|
8850 |
|
8851 |
|
8852 |
|
8853 |
|
8854 |
|
8855 |
|
8856 | insertBefore: function insertBefore(inside, before, insert, root) {
|
8857 | root = root ||
|
8858 |
|
8859 | _.languages;
|
8860 | var grammar = root[inside];
|
8861 |
|
8862 |
|
8863 | var ret = {};
|
8864 |
|
8865 | for (var token in grammar) {
|
8866 | if (grammar.hasOwnProperty(token)) {
|
8867 | if (token == before) {
|
8868 | for (var newToken in insert) {
|
8869 | if (insert.hasOwnProperty(newToken)) {
|
8870 | ret[newToken] = insert[newToken];
|
8871 | }
|
8872 | }
|
8873 | }
|
8874 |
|
8875 |
|
8876 | if (!insert.hasOwnProperty(token)) {
|
8877 | ret[token] = grammar[token];
|
8878 | }
|
8879 | }
|
8880 | }
|
8881 |
|
8882 | var old = root[inside];
|
8883 | root[inside] = ret;
|
8884 |
|
8885 | _.languages.DFS(_.languages, function (key, value) {
|
8886 | if (value === old && key != inside) {
|
8887 | this[key] = ret;
|
8888 | }
|
8889 | });
|
8890 |
|
8891 | return ret;
|
8892 | },
|
8893 |
|
8894 | DFS: function DFS(o, callback, type, visited) {
|
8895 | visited = visited || {};
|
8896 | var objId = _.util.objId;
|
8897 |
|
8898 | for (var i in o) {
|
8899 | if (o.hasOwnProperty(i)) {
|
8900 | callback.call(o, i, o[i], type || i);
|
8901 | var property = o[i];
|
8902 |
|
8903 | var propertyType = _.util.type(property);
|
8904 |
|
8905 | if (propertyType === 'Object' && !visited[objId(property)]) {
|
8906 | visited[objId(property)] = true;
|
8907 | DFS(property, callback, null, visited);
|
8908 | } else if (propertyType === 'Array' && !visited[objId(property)]) {
|
8909 | visited[objId(property)] = true;
|
8910 | DFS(property, callback, i, visited);
|
8911 | }
|
8912 | }
|
8913 | }
|
8914 | }
|
8915 | },
|
8916 | plugins: {},
|
8917 |
|
8918 | |
8919 |
|
8920 |
|
8921 |
|
8922 |
|
8923 |
|
8924 |
|
8925 |
|
8926 |
|
8927 |
|
8928 |
|
8929 |
|
8930 | highlightAll: function highlightAll(async, callback) {
|
8931 | _.highlightAllUnder(document, async, callback);
|
8932 | },
|
8933 |
|
8934 | |
8935 |
|
8936 |
|
8937 |
|
8938 |
|
8939 |
|
8940 |
|
8941 |
|
8942 |
|
8943 |
|
8944 |
|
8945 |
|
8946 |
|
8947 |
|
8948 |
|
8949 | highlightAllUnder: function highlightAllUnder(container, async, callback) {
|
8950 | var env = {
|
8951 | callback: callback,
|
8952 | container: container,
|
8953 | selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
|
8954 | };
|
8955 |
|
8956 | _.hooks.run('before-highlightall', env);
|
8957 |
|
8958 | env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));
|
8959 |
|
8960 | _.hooks.run('before-all-elements-highlight', env);
|
8961 |
|
8962 | for (var i = 0, element; element = env.elements[i++];) {
|
8963 | _.highlightElement(element, async === true, env.callback);
|
8964 | }
|
8965 | },
|
8966 |
|
8967 | |
8968 |
|
8969 |
|
8970 |
|
8971 |
|
8972 |
|
8973 |
|
8974 |
|
8975 |
|
8976 |
|
8977 |
|
8978 |
|
8979 |
|
8980 |
|
8981 |
|
8982 |
|
8983 |
|
8984 |
|
8985 |
|
8986 |
|
8987 |
|
8988 |
|
8989 |
|
8990 |
|
8991 |
|
8992 |
|
8993 |
|
8994 |
|
8995 | highlightElement: function highlightElement(element, async, callback) {
|
8996 |
|
8997 | var language = _.util.getLanguage(element);
|
8998 |
|
8999 | var grammar = _.languages[language];
|
9000 |
|
9001 | _.util.setLanguage(element, language);
|
9002 |
|
9003 |
|
9004 | var parent = element.parentElement;
|
9005 |
|
9006 | if (parent && parent.nodeName.toLowerCase() === 'pre') {
|
9007 | _.util.setLanguage(parent, language);
|
9008 | }
|
9009 |
|
9010 | var code = element.textContent;
|
9011 | var env = {
|
9012 | element: element,
|
9013 | language: language,
|
9014 | grammar: grammar,
|
9015 | code: code
|
9016 | };
|
9017 |
|
9018 | function insertHighlightedCode(highlightedCode) {
|
9019 | env.highlightedCode = highlightedCode;
|
9020 |
|
9021 | _.hooks.run('before-insert', env);
|
9022 |
|
9023 | env.element.innerHTML = env.highlightedCode;
|
9024 |
|
9025 | _.hooks.run('after-highlight', env);
|
9026 |
|
9027 | _.hooks.run('complete', env);
|
9028 |
|
9029 | callback && callback.call(env.element);
|
9030 | }
|
9031 |
|
9032 | _.hooks.run('before-sanity-check', env);
|
9033 |
|
9034 |
|
9035 | parent = env.element.parentElement;
|
9036 |
|
9037 | if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) {
|
9038 | parent.setAttribute('tabindex', '0');
|
9039 | }
|
9040 |
|
9041 | if (!env.code) {
|
9042 | _.hooks.run('complete', env);
|
9043 |
|
9044 | callback && callback.call(env.element);
|
9045 | return;
|
9046 | }
|
9047 |
|
9048 | _.hooks.run('before-highlight', env);
|
9049 |
|
9050 | if (!env.grammar) {
|
9051 | insertHighlightedCode(_.util.encode(env.code));
|
9052 | return;
|
9053 | }
|
9054 |
|
9055 | if (async && _self.Worker) {
|
9056 | var worker = new Worker(_.filename);
|
9057 |
|
9058 | worker.onmessage = function (evt) {
|
9059 | insertHighlightedCode(evt.data);
|
9060 | };
|
9061 |
|
9062 | worker.postMessage(JSON.stringify({
|
9063 | language: env.language,
|
9064 | code: env.code,
|
9065 | immediateClose: true
|
9066 | }));
|
9067 | } else {
|
9068 | insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
|
9069 | }
|
9070 | },
|
9071 |
|
9072 | |
9073 |
|
9074 |
|
9075 |
|
9076 |
|
9077 |
|
9078 |
|
9079 |
|
9080 |
|
9081 |
|
9082 |
|
9083 |
|
9084 |
|
9085 |
|
9086 |
|
9087 |
|
9088 |
|
9089 |
|
9090 |
|
9091 |
|
9092 | highlight: function highlight(text, grammar, language) {
|
9093 | var env = {
|
9094 | code: text,
|
9095 | grammar: grammar,
|
9096 | language: language
|
9097 | };
|
9098 |
|
9099 | _.hooks.run('before-tokenize', env);
|
9100 |
|
9101 | if (!env.grammar) {
|
9102 | throw new Error('The language "' + env.language + '" has no grammar.');
|
9103 | }
|
9104 |
|
9105 | env.tokens = _.tokenize(env.code, env.grammar);
|
9106 |
|
9107 | _.hooks.run('after-tokenize', env);
|
9108 |
|
9109 | return Token.stringify(_.util.encode(env.tokens), env.language);
|
9110 | },
|
9111 |
|
9112 | |
9113 |
|
9114 |
|
9115 |
|
9116 |
|
9117 |
|
9118 |
|
9119 |
|
9120 |
|
9121 |
|
9122 |
|
9123 |
|
9124 |
|
9125 |
|
9126 |
|
9127 |
|
9128 |
|
9129 |
|
9130 |
|
9131 |
|
9132 |
|
9133 |
|
9134 |
|
9135 |
|
9136 | tokenize: function tokenize(text, grammar) {
|
9137 | var rest = grammar.rest;
|
9138 |
|
9139 | if (rest) {
|
9140 | for (var token in rest) {
|
9141 | grammar[token] = rest[token];
|
9142 | }
|
9143 |
|
9144 | delete grammar.rest;
|
9145 | }
|
9146 |
|
9147 | var tokenList = new LinkedList();
|
9148 | addAfter(tokenList, tokenList.head, text);
|
9149 | matchGrammar(text, tokenList, grammar, tokenList.head, 0);
|
9150 | return toArray(tokenList);
|
9151 | },
|
9152 |
|
9153 | |
9154 |
|
9155 |
|
9156 |
|
9157 |
|
9158 | hooks: {
|
9159 | all: {},
|
9160 |
|
9161 | |
9162 |
|
9163 |
|
9164 |
|
9165 |
|
9166 |
|
9167 |
|
9168 |
|
9169 |
|
9170 |
|
9171 |
|
9172 |
|
9173 | add: function add(name, callback) {
|
9174 | var hooks = _.hooks.all;
|
9175 | hooks[name] = hooks[name] || [];
|
9176 | hooks[name].push(callback);
|
9177 | },
|
9178 |
|
9179 | |
9180 |
|
9181 |
|
9182 |
|
9183 |
|
9184 |
|
9185 |
|
9186 |
|
9187 |
|
9188 | run: function run(name, env) {
|
9189 | var callbacks = _.hooks.all[name];
|
9190 |
|
9191 | if (!callbacks || !callbacks.length) {
|
9192 | return;
|
9193 | }
|
9194 |
|
9195 | for (var i = 0, callback; callback = callbacks[i++];) {
|
9196 | callback(env);
|
9197 | }
|
9198 | }
|
9199 | },
|
9200 | Token: Token
|
9201 | };
|
9202 | _self.Prism = _;
|
9203 |
|
9204 |
|
9205 |
|
9206 |
|
9207 | |
9208 |
|
9209 |
|
9210 |
|
9211 |
|
9212 |
|
9213 |
|
9214 |
|
9215 |
|
9216 |
|
9217 |
|
9218 |
|
9219 | function Token(type, content, alias, matchedStr) {
|
9220 | |
9221 |
|
9222 |
|
9223 |
|
9224 |
|
9225 |
|
9226 |
|
9227 |
|
9228 |
|
9229 | this.type = type;
|
9230 | |
9231 |
|
9232 |
|
9233 |
|
9234 |
|
9235 |
|
9236 |
|
9237 |
|
9238 |
|
9239 | this.content = content;
|
9240 | |
9241 |
|
9242 |
|
9243 |
|
9244 |
|
9245 |
|
9246 |
|
9247 |
|
9248 | this.alias = alias;
|
9249 |
|
9250 | this.length = (matchedStr || '').length | 0;
|
9251 | }
|
9252 | |
9253 |
|
9254 |
|
9255 |
|
9256 |
|
9257 |
|
9258 |
|
9259 |
|
9260 |
|
9261 |
|
9262 |
|
9263 |
|
9264 |
|
9265 |
|
9266 |
|
9267 |
|
9268 | |
9269 |
|
9270 |
|
9271 |
|
9272 |
|
9273 |
|
9274 |
|
9275 |
|
9276 |
|
9277 |
|
9278 |
|
9279 |
|
9280 |
|
9281 |
|
9282 | Token.stringify = function stringify(o, language) {
|
9283 | if (typeof o == 'string') {
|
9284 | return o;
|
9285 | }
|
9286 |
|
9287 | if (Array.isArray(o)) {
|
9288 | var s = '';
|
9289 | o.forEach(function (e) {
|
9290 | s += stringify(e, language);
|
9291 | });
|
9292 | return s;
|
9293 | }
|
9294 |
|
9295 | var env = {
|
9296 | type: o.type,
|
9297 | content: stringify(o.content, language),
|
9298 | tag: 'span',
|
9299 | classes: ['token', o.type],
|
9300 | attributes: {},
|
9301 | language: language
|
9302 | };
|
9303 | var aliases = o.alias;
|
9304 |
|
9305 | if (aliases) {
|
9306 | if (Array.isArray(aliases)) {
|
9307 | Array.prototype.push.apply(env.classes, aliases);
|
9308 | } else {
|
9309 | env.classes.push(aliases);
|
9310 | }
|
9311 | }
|
9312 |
|
9313 | _.hooks.run('wrap', env);
|
9314 |
|
9315 | var attributes = '';
|
9316 |
|
9317 | for (var name in env.attributes) {
|
9318 | attributes += ' ' + name + '="' + (env.attributes[name] || '').replace(/"/g, '"') + '"';
|
9319 | }
|
9320 |
|
9321 | return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + attributes + '>' + env.content + '</' + env.tag + '>';
|
9322 | };
|
9323 | |
9324 |
|
9325 |
|
9326 |
|
9327 |
|
9328 |
|
9329 |
|
9330 |
|
9331 |
|
9332 | function matchPattern(pattern, pos, text, lookbehind) {
|
9333 | pattern.lastIndex = pos;
|
9334 | var match = pattern.exec(text);
|
9335 |
|
9336 | if (match && lookbehind && match[1]) {
|
9337 |
|
9338 | var lookbehindLength = match[1].length;
|
9339 | match.index += lookbehindLength;
|
9340 | match[0] = match[0].slice(lookbehindLength);
|
9341 | }
|
9342 |
|
9343 | return match;
|
9344 | }
|
9345 | |
9346 |
|
9347 |
|
9348 |
|
9349 |
|
9350 |
|
9351 |
|
9352 |
|
9353 |
|
9354 |
|
9355 |
|
9356 |
|
9357 |
|
9358 |
|
9359 |
|
9360 |
|
9361 | function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
|
9362 | for (var token in grammar) {
|
9363 | if (!grammar.hasOwnProperty(token) || !grammar[token]) {
|
9364 | continue;
|
9365 | }
|
9366 |
|
9367 | var patterns = grammar[token];
|
9368 | patterns = Array.isArray(patterns) ? patterns : [patterns];
|
9369 |
|
9370 | for (var j = 0; j < patterns.length; ++j) {
|
9371 | if (rematch && rematch.cause == token + ',' + j) {
|
9372 | return;
|
9373 | }
|
9374 |
|
9375 | var patternObj = patterns[j];
|
9376 | var inside = patternObj.inside;
|
9377 | var lookbehind = !!patternObj.lookbehind;
|
9378 | var greedy = !!patternObj.greedy;
|
9379 | var alias = patternObj.alias;
|
9380 |
|
9381 | if (greedy && !patternObj.pattern.global) {
|
9382 |
|
9383 | var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
|
9384 | patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');
|
9385 | }
|
9386 |
|
9387 |
|
9388 |
|
9389 | var pattern = patternObj.pattern || patternObj;
|
9390 |
|
9391 | for (
|
9392 | var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
|
9393 | if (rematch && pos >= rematch.reach) {
|
9394 | break;
|
9395 | }
|
9396 |
|
9397 | var str = currentNode.value;
|
9398 |
|
9399 | if (tokenList.length > text.length) {
|
9400 |
|
9401 | return;
|
9402 | }
|
9403 |
|
9404 | if (str instanceof Token) {
|
9405 | continue;
|
9406 | }
|
9407 |
|
9408 | var removeCount = 1;
|
9409 |
|
9410 | var match;
|
9411 |
|
9412 | if (greedy) {
|
9413 | match = matchPattern(pattern, pos, text, lookbehind);
|
9414 |
|
9415 | if (!match || match.index >= text.length) {
|
9416 | break;
|
9417 | }
|
9418 |
|
9419 | var from = match.index;
|
9420 | var to = match.index + match[0].length;
|
9421 | var p = pos;
|
9422 |
|
9423 | p += currentNode.value.length;
|
9424 |
|
9425 | while (from >= p) {
|
9426 | currentNode = currentNode.next;
|
9427 | p += currentNode.value.length;
|
9428 | }
|
9429 |
|
9430 |
|
9431 | p -= currentNode.value.length;
|
9432 | pos = p;
|
9433 |
|
9434 | if (currentNode.value instanceof Token) {
|
9435 | continue;
|
9436 | }
|
9437 |
|
9438 |
|
9439 | for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string'); k = k.next) {
|
9440 | removeCount++;
|
9441 | p += k.value.length;
|
9442 | }
|
9443 |
|
9444 | removeCount--;
|
9445 |
|
9446 | str = text.slice(pos, p);
|
9447 | match.index -= pos;
|
9448 | } else {
|
9449 | match = matchPattern(pattern, 0, str, lookbehind);
|
9450 |
|
9451 | if (!match) {
|
9452 | continue;
|
9453 | }
|
9454 | }
|
9455 |
|
9456 |
|
9457 | var from = match.index;
|
9458 | var matchStr = match[0];
|
9459 | var before = str.slice(0, from);
|
9460 | var after = str.slice(from + matchStr.length);
|
9461 | var reach = pos + str.length;
|
9462 |
|
9463 | if (rematch && reach > rematch.reach) {
|
9464 | rematch.reach = reach;
|
9465 | }
|
9466 |
|
9467 | var removeFrom = currentNode.prev;
|
9468 |
|
9469 | if (before) {
|
9470 | removeFrom = addAfter(tokenList, removeFrom, before);
|
9471 | pos += before.length;
|
9472 | }
|
9473 |
|
9474 | removeRange(tokenList, removeFrom, removeCount);
|
9475 | var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
|
9476 | currentNode = addAfter(tokenList, removeFrom, wrapped);
|
9477 |
|
9478 | if (after) {
|
9479 | addAfter(tokenList, currentNode, after);
|
9480 | }
|
9481 |
|
9482 | if (removeCount > 1) {
|
9483 |
|
9484 |
|
9485 |
|
9486 |
|
9487 | var nestedRematch = {
|
9488 | cause: token + ',' + j,
|
9489 | reach: reach
|
9490 | };
|
9491 | matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
|
9492 |
|
9493 | if (rematch && nestedRematch.reach > rematch.reach) {
|
9494 | rematch.reach = nestedRematch.reach;
|
9495 | }
|
9496 | }
|
9497 | }
|
9498 | }
|
9499 | }
|
9500 | }
|
9501 | |
9502 |
|
9503 |
|
9504 |
|
9505 |
|
9506 |
|
9507 |
|
9508 |
|
9509 |
|
9510 | |
9511 |
|
9512 |
|
9513 |
|
9514 |
|
9515 |
|
9516 | function LinkedList() {
|
9517 |
|
9518 | var head = {
|
9519 | value: null,
|
9520 | prev: null,
|
9521 | next: null
|
9522 | };
|
9523 |
|
9524 |
|
9525 | var tail = {
|
9526 | value: null,
|
9527 | prev: head,
|
9528 | next: null
|
9529 | };
|
9530 | head.next = tail;
|
9531 |
|
9532 |
|
9533 | this.head = head;
|
9534 |
|
9535 |
|
9536 | this.tail = tail;
|
9537 | this.length = 0;
|
9538 | }
|
9539 | |
9540 |
|
9541 |
|
9542 |
|
9543 |
|
9544 |
|
9545 |
|
9546 |
|
9547 |
|
9548 |
|
9549 |
|
9550 | function addAfter(list, node, value) {
|
9551 |
|
9552 | var next = node.next;
|
9553 | var newNode = {
|
9554 | value: value,
|
9555 | prev: node,
|
9556 | next: next
|
9557 | };
|
9558 | node.next = newNode;
|
9559 | next.prev = newNode;
|
9560 | list.length++;
|
9561 | return newNode;
|
9562 | }
|
9563 | |
9564 |
|
9565 |
|
9566 |
|
9567 |
|
9568 |
|
9569 |
|
9570 |
|
9571 |
|
9572 |
|
9573 | function removeRange(list, node, count) {
|
9574 | var next = node.next;
|
9575 |
|
9576 | for (var i = 0; i < count && next !== list.tail; i++) {
|
9577 | next = next.next;
|
9578 | }
|
9579 |
|
9580 | node.next = next;
|
9581 | next.prev = node;
|
9582 | list.length -= i;
|
9583 | }
|
9584 | |
9585 |
|
9586 |
|
9587 |
|
9588 |
|
9589 |
|
9590 |
|
9591 | function toArray(list) {
|
9592 | var array = [];
|
9593 | var node = list.head.next;
|
9594 |
|
9595 | while (node !== list.tail) {
|
9596 | array.push(node.value);
|
9597 | node = node.next;
|
9598 | }
|
9599 |
|
9600 | return array;
|
9601 | }
|
9602 |
|
9603 | if (!_self.document) {
|
9604 | if (!_self.addEventListener) {
|
9605 |
|
9606 | return _;
|
9607 | }
|
9608 |
|
9609 | if (!_.disableWorkerMessageHandler) {
|
9610 |
|
9611 | _self.addEventListener('message', function (evt) {
|
9612 | var message = JSON.parse(evt.data);
|
9613 | var lang = message.language;
|
9614 | var code = message.code;
|
9615 | var immediateClose = message.immediateClose;
|
9616 |
|
9617 | _self.postMessage(_.highlight(code, _.languages[lang], lang));
|
9618 |
|
9619 | if (immediateClose) {
|
9620 | _self.close();
|
9621 | }
|
9622 | }, false);
|
9623 | }
|
9624 |
|
9625 | return _;
|
9626 | }
|
9627 |
|
9628 |
|
9629 | var script = _.util.currentScript();
|
9630 |
|
9631 | if (script) {
|
9632 | _.filename = script.src;
|
9633 |
|
9634 | if (script.hasAttribute('data-manual')) {
|
9635 | _.manual = true;
|
9636 | }
|
9637 | }
|
9638 |
|
9639 | function highlightAutomaticallyCallback() {
|
9640 | if (!_.manual) {
|
9641 | _.highlightAll();
|
9642 | }
|
9643 | }
|
9644 |
|
9645 | if (!_.manual) {
|
9646 |
|
9647 |
|
9648 |
|
9649 |
|
9650 |
|
9651 |
|
9652 | var readyState = document.readyState;
|
9653 |
|
9654 | if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
|
9655 | document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
|
9656 | } else {
|
9657 | if (window.requestAnimationFrame) {
|
9658 | window.requestAnimationFrame(highlightAutomaticallyCallback);
|
9659 | } else {
|
9660 | window.setTimeout(highlightAutomaticallyCallback, 16);
|
9661 | }
|
9662 | }
|
9663 | }
|
9664 |
|
9665 | return _;
|
9666 | }(_self);
|
9667 |
|
9668 | if (module.exports) {
|
9669 | module.exports = Prism;
|
9670 | }
|
9671 |
|
9672 |
|
9673 | if (typeof commonjsGlobal !== 'undefined') {
|
9674 | commonjsGlobal.Prism = Prism;
|
9675 | }
|
9676 |
|
9677 | |
9678 |
|
9679 |
|
9680 |
|
9681 |
|
9682 |
|
9683 |
|
9684 |
|
9685 |
|
9686 |
|
9687 |
|
9688 |
|
9689 |
|
9690 |
|
9691 |
|
9692 |
|
9693 |
|
9694 |
|
9695 |
|
9696 |
|
9697 |
|
9698 | |
9699 |
|
9700 |
|
9701 |
|
9702 |
|
9703 |
|
9704 |
|
9705 |
|
9706 | |
9707 |
|
9708 |
|
9709 |
|
9710 |
|
9711 |
|
9712 |
|
9713 |
|
9714 |
|
9715 |
|
9716 | |
9717 |
|
9718 |
|
9719 |
|
9720 |
|
9721 |
|
9722 |
|
9723 |
|
9724 | })(prismCore);
|
9725 |
|
9726 | var clike_1 = clike$1;
|
9727 | clike$1.displayName = 'clike';
|
9728 | clike$1.aliases = [];
|
9729 |
|
9730 | function clike$1(Prism) {
|
9731 | Prism.languages.clike = {
|
9732 | comment: [{
|
9733 | pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
9734 | lookbehind: true,
|
9735 | greedy: true
|
9736 | }, {
|
9737 | pattern: /(^|[^\\:])\/\/.*/,
|
9738 | lookbehind: true,
|
9739 | greedy: true
|
9740 | }],
|
9741 | string: {
|
9742 | pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
|
9743 | greedy: true
|
9744 | },
|
9745 | 'class-name': {
|
9746 | pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
|
9747 | lookbehind: true,
|
9748 | inside: {
|
9749 | punctuation: /[.\\]/
|
9750 | }
|
9751 | },
|
9752 | keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
|
9753 | boolean: /\b(?:false|true)\b/,
|
9754 | function: /\b\w+(?=\()/,
|
9755 | number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
|
9756 | operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
|
9757 | punctuation: /[{}[\];(),.:]/
|
9758 | };
|
9759 | }
|
9760 |
|
9761 | var javascript_1 = javascript;
|
9762 | javascript.displayName = 'javascript';
|
9763 | javascript.aliases = ['js'];
|
9764 |
|
9765 | function javascript(Prism) {
|
9766 | Prism.languages.javascript = Prism.languages.extend('clike', {
|
9767 | 'class-name': [Prism.languages.clike['class-name'], {
|
9768 | pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
|
9769 | lookbehind: true
|
9770 | }],
|
9771 | keyword: [{
|
9772 | pattern: /((?:^|\})\s*)catch\b/,
|
9773 | lookbehind: true
|
9774 | }, {
|
9775 | pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
|
9776 | lookbehind: true
|
9777 | }],
|
9778 |
|
9779 | function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
|
9780 | number: {
|
9781 | pattern: RegExp(/(^|[^\w$])/.source + '(?:' + (
|
9782 | /NaN|Infinity/.source + '|' +
|
9783 | /0[bB][01]+(?:_[01]+)*n?/.source + '|' + // octal integer
|
9784 | /0[oO][0-7]+(?:_[0-7]+)*n?/.source + '|' + // hexadecimal integer
|
9785 | /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + '|' + // decimal bigint
|
9786 | /\d+(?:_\d+)*n/.source + '|' +
|
9787 | /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ')' + /(?![\w$])/.source),
|
9788 | lookbehind: true
|
9789 | },
|
9790 | operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
|
9791 | });
|
9792 | Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
|
9793 | Prism.languages.insertBefore('javascript', 'keyword', {
|
9794 | regex: {
|
9795 |
|
9796 | pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
|
9797 | lookbehind: true,
|
9798 | greedy: true,
|
9799 | inside: {
|
9800 | 'regex-source': {
|
9801 | pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
|
9802 | lookbehind: true,
|
9803 | alias: 'language-regex',
|
9804 | inside: Prism.languages.regex
|
9805 | },
|
9806 | 'regex-delimiter': /^\/|\/$/,
|
9807 | 'regex-flags': /^[a-z]+$/
|
9808 | }
|
9809 | },
|
9810 |
|
9811 | 'function-variable': {
|
9812 | pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
|
9813 | alias: 'function'
|
9814 | },
|
9815 | parameter: [{
|
9816 | pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
|
9817 | lookbehind: true,
|
9818 | inside: Prism.languages.javascript
|
9819 | }, {
|
9820 | pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
|
9821 | lookbehind: true,
|
9822 | inside: Prism.languages.javascript
|
9823 | }, {
|
9824 | pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
|
9825 | lookbehind: true,
|
9826 | inside: Prism.languages.javascript
|
9827 | }, {
|
9828 | pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
|
9829 | lookbehind: true,
|
9830 | inside: Prism.languages.javascript
|
9831 | }],
|
9832 | constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
|
9833 | });
|
9834 | Prism.languages.insertBefore('javascript', 'string', {
|
9835 | hashbang: {
|
9836 | pattern: /^#!.*/,
|
9837 | greedy: true,
|
9838 | alias: 'comment'
|
9839 | },
|
9840 | 'template-string': {
|
9841 | pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
|
9842 | greedy: true,
|
9843 | inside: {
|
9844 | 'template-punctuation': {
|
9845 | pattern: /^`|`$/,
|
9846 | alias: 'string'
|
9847 | },
|
9848 | interpolation: {
|
9849 | pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
|
9850 | lookbehind: true,
|
9851 | inside: {
|
9852 | 'interpolation-punctuation': {
|
9853 | pattern: /^\$\{|\}$/,
|
9854 | alias: 'punctuation'
|
9855 | },
|
9856 | rest: Prism.languages.javascript
|
9857 | }
|
9858 | },
|
9859 | string: /[\s\S]+/
|
9860 | }
|
9861 | },
|
9862 | 'string-property': {
|
9863 | pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
|
9864 | lookbehind: true,
|
9865 | greedy: true,
|
9866 | alias: 'property'
|
9867 | }
|
9868 | });
|
9869 | Prism.languages.insertBefore('javascript', 'operator', {
|
9870 | 'literal-property': {
|
9871 | pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
|
9872 | lookbehind: true,
|
9873 | alias: 'property'
|
9874 | }
|
9875 | });
|
9876 |
|
9877 | if (Prism.languages.markup) {
|
9878 | Prism.languages.markup.tag.addInlined('script', 'javascript');
|
9879 |
|
9880 |
|
9881 | Prism.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, 'javascript');
|
9882 | }
|
9883 |
|
9884 | Prism.languages.js = Prism.languages.javascript;
|
9885 | }
|
9886 |
|
9887 |
|
9888 |
|
9889 |
|
9890 |
|
9891 | var ctx = (typeof globalThis === "undefined" ? "undefined" : _typeof(globalThis)) === 'object' ? globalThis : (typeof self === "undefined" ? "undefined" : _typeof(self)) === 'object' ? self : (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' ? window : _typeof(commonjsGlobal) === 'object' ? commonjsGlobal : {};
|
9892 | var restore = capture();
|
9893 | ctx.Prism = {
|
9894 | manual: true,
|
9895 | disableWorkerMessageHandler: true
|
9896 | };
|
9897 |
|
9898 |
|
9899 | var h = hastscript;
|
9900 | var decode = parseEntities_1;
|
9901 | var Prism = prismCore.exports;
|
9902 | var markup = markup_1;
|
9903 | var css = css_1;
|
9904 | var clike = clike_1;
|
9905 | var js = javascript_1;
|
9906 | restore();
|
9907 | var own = {}.hasOwnProperty;
|
9908 |
|
9909 | function Refractor() {}
|
9910 |
|
9911 | Refractor.prototype = Prism;
|
9912 |
|
9913 | var refract = new Refractor();
|
9914 |
|
9915 | var core = refract;
|
9916 |
|
9917 | refract.highlight = highlight;
|
9918 | refract.register = register;
|
9919 | refract.alias = alias;
|
9920 | refract.registered = registered;
|
9921 | refract.listLanguages = listLanguages;
|
9922 |
|
9923 | register(markup);
|
9924 | register(css);
|
9925 | register(clike);
|
9926 | register(js);
|
9927 | refract.util.encode = encode;
|
9928 | refract.Token.stringify = stringify;
|
9929 |
|
9930 | function register(grammar) {
|
9931 | if (typeof grammar !== 'function' || !grammar.displayName) {
|
9932 | throw new Error('Expected `function` for `grammar`, got `' + grammar + '`');
|
9933 | }
|
9934 |
|
9935 |
|
9936 | if (refract.languages[grammar.displayName] === undefined) {
|
9937 | grammar(refract);
|
9938 | }
|
9939 | }
|
9940 |
|
9941 | function alias(name, alias) {
|
9942 | var languages = refract.languages;
|
9943 | var map = name;
|
9944 | var key;
|
9945 | var list;
|
9946 | var length;
|
9947 | var index;
|
9948 |
|
9949 | if (alias) {
|
9950 | map = {};
|
9951 | map[name] = alias;
|
9952 | }
|
9953 |
|
9954 | for (key in map) {
|
9955 | list = map[key];
|
9956 | list = typeof list === 'string' ? [list] : list;
|
9957 | length = list.length;
|
9958 | index = -1;
|
9959 |
|
9960 | while (++index < length) {
|
9961 | languages[list[index]] = languages[key];
|
9962 | }
|
9963 | }
|
9964 | }
|
9965 |
|
9966 | function highlight(value, name) {
|
9967 | var sup = Prism.highlight;
|
9968 | var grammar;
|
9969 |
|
9970 | if (typeof value !== 'string') {
|
9971 | throw new Error('Expected `string` for `value`, got `' + value + '`');
|
9972 | }
|
9973 |
|
9974 |
|
9975 | if (refract.util.type(name) === 'Object') {
|
9976 | grammar = name;
|
9977 | name = null;
|
9978 | } else {
|
9979 | if (typeof name !== 'string') {
|
9980 | throw new Error('Expected `string` for `name`, got `' + name + '`');
|
9981 | }
|
9982 |
|
9983 | if (own.call(refract.languages, name)) {
|
9984 | grammar = refract.languages[name];
|
9985 | } else {
|
9986 | throw new Error('Unknown language: `' + name + '` is not registered');
|
9987 | }
|
9988 | }
|
9989 |
|
9990 | return sup.call(this, value, grammar, name);
|
9991 | }
|
9992 |
|
9993 | function registered(language) {
|
9994 | if (typeof language !== 'string') {
|
9995 | throw new Error('Expected `string` for `language`, got `' + language + '`');
|
9996 | }
|
9997 |
|
9998 | return own.call(refract.languages, language);
|
9999 | }
|
10000 |
|
10001 | function listLanguages() {
|
10002 | var languages = refract.languages;
|
10003 | var list = [];
|
10004 | var language;
|
10005 |
|
10006 | for (language in languages) {
|
10007 | if (own.call(languages, language) && _typeof(languages[language]) === 'object') {
|
10008 | list.push(language);
|
10009 | }
|
10010 | }
|
10011 |
|
10012 | return list;
|
10013 | }
|
10014 |
|
10015 | function stringify(value, language, parent) {
|
10016 | var env;
|
10017 |
|
10018 | if (typeof value === 'string') {
|
10019 | return {
|
10020 | type: 'text',
|
10021 | value: value
|
10022 | };
|
10023 | }
|
10024 |
|
10025 | if (refract.util.type(value) === 'Array') {
|
10026 | return stringifyAll(value, language);
|
10027 | }
|
10028 |
|
10029 | env = {
|
10030 | type: value.type,
|
10031 | content: refract.Token.stringify(value.content, language, parent),
|
10032 | tag: 'span',
|
10033 | classes: ['token', value.type],
|
10034 | attributes: {},
|
10035 | language: language,
|
10036 | parent: parent
|
10037 | };
|
10038 |
|
10039 | if (value.alias) {
|
10040 | env.classes = env.classes.concat(value.alias);
|
10041 | }
|
10042 |
|
10043 | refract.hooks.run('wrap', env);
|
10044 | return h(env.tag + '.' + env.classes.join('.'), attributes(env.attributes), env.content);
|
10045 | }
|
10046 |
|
10047 | function stringifyAll(values, language) {
|
10048 | var result = [];
|
10049 | var length = values.length;
|
10050 | var index = -1;
|
10051 | var value;
|
10052 |
|
10053 | while (++index < length) {
|
10054 | value = values[index];
|
10055 |
|
10056 | if (value !== '' && value !== null && value !== undefined) {
|
10057 | result.push(value);
|
10058 | }
|
10059 | }
|
10060 |
|
10061 | index = -1;
|
10062 | length = result.length;
|
10063 |
|
10064 | while (++index < length) {
|
10065 | value = result[index];
|
10066 | result[index] = refract.Token.stringify(value, language, result);
|
10067 | }
|
10068 |
|
10069 | return result;
|
10070 | }
|
10071 |
|
10072 | function encode(tokens) {
|
10073 | return tokens;
|
10074 | }
|
10075 |
|
10076 | function attributes(attrs) {
|
10077 | var key;
|
10078 |
|
10079 | for (key in attrs) {
|
10080 | attrs[key] = decode(attrs[key]);
|
10081 | }
|
10082 |
|
10083 | return attrs;
|
10084 | }
|
10085 |
|
10086 | function capture() {
|
10087 | var defined = ('Prism' in ctx);
|
10088 |
|
10089 |
|
10090 | var current = defined ? ctx.Prism : undefined;
|
10091 | return restore;
|
10092 |
|
10093 | function restore() {
|
10094 |
|
10095 | if (defined) {
|
10096 | ctx.Prism = current;
|
10097 | } else {
|
10098 | delete ctx.Prism;
|
10099 | }
|
10100 |
|
10101 | defined = undefined;
|
10102 | current = undefined;
|
10103 | }
|
10104 | }
|
10105 |
|
10106 | var SyntaxHighlighter$1 = highlight$1(core, {});
|
10107 |
|
10108 | SyntaxHighlighter$1.registerLanguage = function (_, language) {
|
10109 | return core.register(language);
|
10110 | };
|
10111 |
|
10112 | var ReactSyntaxHighlighter = SyntaxHighlighter$1;
|
10113 | var navigator = window_1.navigator,
|
10114 | document$1 = window_1.document,
|
10115 | globalWindow = window_1.window;
|
10116 | ReactSyntaxHighlighter.registerLanguage('jsextra', jsExtras$1);
|
10117 | ReactSyntaxHighlighter.registerLanguage('jsx', jsx$1);
|
10118 | ReactSyntaxHighlighter.registerLanguage('json', json$1);
|
10119 | ReactSyntaxHighlighter.registerLanguage('yml', yaml$1);
|
10120 | ReactSyntaxHighlighter.registerLanguage('md', markdown$1);
|
10121 | ReactSyntaxHighlighter.registerLanguage('bash', bash$1);
|
10122 | ReactSyntaxHighlighter.registerLanguage('css', css$2);
|
10123 | ReactSyntaxHighlighter.registerLanguage('html', markup$2);
|
10124 | ReactSyntaxHighlighter.registerLanguage('tsx', tsx$1);
|
10125 | ReactSyntaxHighlighter.registerLanguage('typescript', typescript$1);
|
10126 | ReactSyntaxHighlighter.registerLanguage('graphql', graphql$1);
|
10127 | var themedSyntax = memoize(2)(function (theme) {
|
10128 | return Object.entries(theme.code || {}).reduce(function (acc, _ref8) {
|
10129 | var _ref9 = _slicedToArray(_ref8, 2),
|
10130 | key = _ref9[0],
|
10131 | val = _ref9[1];
|
10132 |
|
10133 | return Object.assign(Object.assign({}, acc), _defineProperty2({}, "* .".concat(key), val));
|
10134 | }, {});
|
10135 | });
|
10136 | var copyToClipboard = createCopyToClipboardFunction();
|
10137 |
|
10138 | function createCopyToClipboardFunction() {
|
10139 | var _this = this;
|
10140 |
|
10141 | if (navigator === null || navigator === void 0 ? void 0 : navigator.clipboard) {
|
10142 | return function (text) {
|
10143 | return navigator.clipboard.writeText(text);
|
10144 | };
|
10145 | }
|
10146 |
|
10147 | return function (text) {
|
10148 | return __awaiter(_this, void 0, void 0, regeneratorRuntime.mark(function _callee() {
|
10149 | var tmp, focus;
|
10150 | return regeneratorRuntime.wrap(function _callee$(_context) {
|
10151 | while (1) {
|
10152 | switch (_context.prev = _context.next) {
|
10153 | case 0:
|
10154 | tmp = document$1.createElement('TEXTAREA');
|
10155 | focus = document$1.activeElement;
|
10156 | tmp.value = text;
|
10157 | document$1.body.appendChild(tmp);
|
10158 | tmp.select();
|
10159 | document$1.execCommand('copy');
|
10160 | document$1.body.removeChild(tmp);
|
10161 | focus.focus();
|
10162 |
|
10163 | case 8:
|
10164 | case "end":
|
10165 | return _context.stop();
|
10166 | }
|
10167 | }
|
10168 | }, _callee);
|
10169 | }));
|
10170 | };
|
10171 | }
|
10172 |
|
10173 | var Wrapper = styled.div(function (_ref10) {
|
10174 | var theme = _ref10.theme;
|
10175 | return {
|
10176 | position: 'relative',
|
10177 | overflow: 'hidden',
|
10178 | color: theme.color.defaultText
|
10179 | };
|
10180 | }, function (_ref11) {
|
10181 | var theme = _ref11.theme,
|
10182 | bordered = _ref11.bordered;
|
10183 | return bordered ? {
|
10184 | border: "1px solid ".concat(theme.appBorderColor),
|
10185 | borderRadius: theme.borderRadius,
|
10186 | background: theme.background.content
|
10187 | } : {};
|
10188 | });
|
10189 | var Scroller = styled(function (_ref12) {
|
10190 | var children = _ref12.children,
|
10191 | className = _ref12.className;
|
10192 | return React__default.createElement(ScrollArea, {
|
10193 | horizontal: true,
|
10194 | vertical: true,
|
10195 | className: className
|
10196 | }, children);
|
10197 | })({
|
10198 | position: 'relative'
|
10199 | }, function (_ref13) {
|
10200 | var theme = _ref13.theme;
|
10201 | return themedSyntax(theme);
|
10202 | });
|
10203 | var Pre = styled.pre(function (_ref14) {
|
10204 | var theme = _ref14.theme,
|
10205 | padded = _ref14.padded;
|
10206 | return {
|
10207 | display: 'flex',
|
10208 | justifyContent: 'flex-start',
|
10209 | margin: 0,
|
10210 | padding: padded ? theme.layoutMargin : 0
|
10211 | };
|
10212 | });
|
10213 |
|
10214 |
|
10215 |
|
10216 |
|
10217 |
|
10218 | var Code = styled.div(function (_ref15) {
|
10219 | var theme = _ref15.theme;
|
10220 | return {
|
10221 | flex: 1,
|
10222 | paddingLeft: 2,
|
10223 | paddingRight: theme.layoutMargin,
|
10224 | opacity: 1
|
10225 | };
|
10226 | });
|
10227 |
|
10228 | var SyntaxHighlighter = function SyntaxHighlighter(_a) {
|
10229 | var children = _a.children,
|
10230 | _a$language = _a.language,
|
10231 | language = _a$language === void 0 ? 'jsx' : _a$language,
|
10232 | _a$copyable = _a.copyable,
|
10233 | copyable = _a$copyable === void 0 ? false : _a$copyable,
|
10234 | _a$bordered = _a.bordered,
|
10235 | bordered = _a$bordered === void 0 ? false : _a$bordered,
|
10236 | _a$padded = _a.padded,
|
10237 | padded = _a$padded === void 0 ? false : _a$padded,
|
10238 | _a$format = _a.format,
|
10239 | format = _a$format === void 0 ? true : _a$format,
|
10240 | _a$formatter = _a.formatter,
|
10241 | formatter = _a$formatter === void 0 ? null : _a$formatter,
|
10242 | _a$className = _a.className,
|
10243 | className = _a$className === void 0 ? null : _a$className,
|
10244 | _a$showLineNumbers = _a.showLineNumbers,
|
10245 | showLineNumbers = _a$showLineNumbers === void 0 ? false : _a$showLineNumbers,
|
10246 | rest = __rest(_a, ["children", "language", "copyable", "bordered", "padded", "format", "formatter", "className", "showLineNumbers"]);
|
10247 |
|
10248 | if (typeof children !== 'string' || !children.trim()) {
|
10249 | return null;
|
10250 | }
|
10251 |
|
10252 | var highlightableCode = formatter ? formatter(format, children) : children.trim();
|
10253 |
|
10254 | var _useState = useState(false),
|
10255 | _useState2 = _slicedToArray(_useState, 2),
|
10256 | copied = _useState2[0],
|
10257 | setCopied = _useState2[1];
|
10258 |
|
10259 | var onClick = useCallback(function (e) {
|
10260 | e.preventDefault();
|
10261 | var selectedText = globalWindow.getSelection().toString();
|
10262 | var textToCopy = e.type !== 'click' && selectedText ? selectedText : highlightableCode;
|
10263 | copyToClipboard(textToCopy).then(function () {
|
10264 | setCopied(true);
|
10265 | globalWindow.setTimeout(function () {
|
10266 | return setCopied(false);
|
10267 | }, 1500);
|
10268 | }).catch(logger.error);
|
10269 | }, []);
|
10270 | return React__default.createElement(Wrapper, {
|
10271 | bordered: bordered,
|
10272 | padded: padded,
|
10273 | className: className,
|
10274 | onCopyCapture: onClick
|
10275 | }, React__default.createElement(Scroller, null, React__default.createElement(ReactSyntaxHighlighter, Object.assign({
|
10276 | padded: padded || bordered,
|
10277 | language: language,
|
10278 | showLineNumbers: showLineNumbers,
|
10279 | showInlineLineNumbers: showLineNumbers,
|
10280 | useInlineStyles: false,
|
10281 | PreTag: Pre,
|
10282 | CodeTag: Code,
|
10283 | lineNumberContainerStyle: {}
|
10284 | }, rest), highlightableCode)), copyable ? React__default.createElement(ActionBar, {
|
10285 | actionItems: [{
|
10286 | title: copied ? 'Copied' : 'Copy',
|
10287 | onClick: onClick
|
10288 | }]
|
10289 | }) : null);
|
10290 | };
|
10291 |
|
10292 | export { SyntaxHighlighter, createCopyToClipboardFunction, SyntaxHighlighter as default };
|