From 12c6eb05c538acf66fbd90683769654db0111974 Mon Sep 17 00:00:00 2001 From: Yaroslav Admin Date: Sun, 17 May 2020 23:30:50 +0200 Subject: [PATCH] fix(client): check in bundled client code into version control New script will take care about building assets and also checking that bundled assets are up-to-date as part of CI. This provides some improvements over the previous approach from https://github.com/karma-runner/karma/commit/f5521df7df5cd1201b5dce28dc4e326b1ffc41fd#commitcomment-38967493: 1. It is possible to install `karma` from GitHub branch without the assumption that `browserify` is installed in user's project. 1. Karma contributors no longer need to run `npm run build` unless they want to change client code. 1. Simplifies runtime code. --- .gitignore | 2 - .travis.yml | 4 +- appveyor.yml | 2 +- docs/dev/02-making-changes.md | 2 - lib/server.js | 5 - lib/utils/bundle-utils.js | 26 - package.json | 4 +- scripts/client.js | 51 + static/context.js | 2645 ++++++++++++++++++++++++ static/karma.js | 2858 ++++++++++++++++++++++++++ test/unit/utils/bundle-utils.spec.js | 42 - 11 files changed, 5558 insertions(+), 83 deletions(-) delete mode 100644 lib/utils/bundle-utils.js create mode 100644 scripts/client.js create mode 100644 static/context.js create mode 100644 static/karma.js delete mode 100644 test/unit/utils/bundle-utils.spec.js diff --git a/.gitignore b/.gitignore index 616e0d81c..e273bb3c7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,5 @@ node_modules npm-debug.log -static/context.js -static/karma.js .idea/* *.iml docs/_build diff --git a/.travis.yml b/.travis.yml index c7bad2dd9..7c1e548d8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,14 +7,12 @@ jobs: - node_js: "10" script: - npm run init - - npm run build - npm run test:unit - npm run test:e2e - node_js: "12" script: - npm run init - - npm run build - npm run test:unit - npm run test:e2e @@ -23,7 +21,7 @@ jobs: - npm run init - commitlint-travis - npm run lint - - npm run build + - npm run build:check - npm run test:unit - npm run test:e2e - npm run test:client diff --git a/appveyor.yml b/appveyor.yml index 2e25384b9..ee5c94f8e 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -24,7 +24,7 @@ install: - npm run init:windows test_script: - - npm run appveyor + - npm run test:appveyor build: off diff --git a/docs/dev/02-making-changes.md b/docs/dev/02-making-changes.md index 9d1811302..489e978e2 100644 --- a/docs/dev/02-making-changes.md +++ b/docs/dev/02-making-changes.md @@ -27,8 +27,6 @@ Here are some tips on how to set up a Karma workspace and how to send a good pul $ npm run init # or if you're on Windows $ npm run init:windows - - $ npm run build ``` ## Testing and Building diff --git a/lib/server.js b/lib/server.js index e79a2aa22..25f4e3c05 100644 --- a/lib/server.js +++ b/lib/server.js @@ -8,7 +8,6 @@ const tmp = require('tmp') const fs = require('fs') const path = require('path') -const BundleUtils = require('./utils/bundle-utils') const NetUtils = require('./utils/net-utils') const root = global || window || this @@ -116,10 +115,6 @@ class Server extends KarmaEventEmitter { async start () { const config = this.get('config') try { - await Promise.all([ - BundleUtils.bundleResourceIfNotExist('client/main.js', 'static/karma.js'), - BundleUtils.bundleResourceIfNotExist('context/main.js', 'static/context.js') - ]) this._boundServer = await NetUtils.bindAvailablePort(config.port, config.listenAddress) this._boundServer.on('connection', (socket) => { // Attach an error handler to avoid UncaughtException errors. diff --git a/lib/utils/bundle-utils.js b/lib/utils/bundle-utils.js deleted file mode 100644 index 760c61d31..000000000 --- a/lib/utils/bundle-utils.js +++ /dev/null @@ -1,26 +0,0 @@ -'use strict' -const PathUtils = require('./path-utils') -const fs = require('fs') - -const BundleUtils = { - bundleResource (inPath, outPath) { - return new Promise((resolve, reject) => { - require('browserify')(inPath) - .bundle() - .pipe(fs.createWriteStream(outPath)) - .once('finish', () => resolve()) - .once('error', (e) => reject(e)) - }) - }, - - bundleResourceIfNotExist (inPath, outPath) { - inPath = PathUtils.calculateAbsolutePath(inPath) - outPath = PathUtils.calculateAbsolutePath(outPath) - - return fs.existsSync(outPath) - ? Promise.resolve() - : BundleUtils.bundleResource(inPath, outPath) - } -} - -module.exports = BundleUtils diff --git a/package.json b/package.json index bd79da30c..65405da36 100644 --- a/package.json +++ b/package.json @@ -491,14 +491,14 @@ "test:e2e": "cucumber-js test/e2e/*.feature", "test:client": "grunt test:client", "test": "npm run test:unit && npm run test:e2e && npm run test:client", - "build": "grunt build", + "build": "node scripts/client.js build", + "build:check": "node scripts/client.js check", "test:appveyor": "grunt test-appveyor", "test:integration": "./scripts/integration-tests.sh", "link": "node --eval \"path=require('path'); require('fs').symlinkSync(path.resolve(__dirname), path.resolve(__dirname, 'node_modules', 'karma'), 'junction')\"", "unlink": "node --eval \"require('fs').unlinkSync(require('path').resolve(__dirname, 'node_modules', 'karma'))\"", "init": "rm -rf node_modules/karma && cd node_modules && ln -nsf ../ karma && cd ../", "init:windows": "(IF EXIST node_modules\\karma (rmdir node_modules\\karma /S /q)) && npm run link", - "appveyor": "npm run build && npm run test:appveyor", "semantic-release": "semantic-release" } } diff --git a/scripts/client.js b/scripts/client.js new file mode 100644 index 000000000..29dfabc72 --- /dev/null +++ b/scripts/client.js @@ -0,0 +1,51 @@ +const browserify = require('browserify') +const fs = require('fs') +const { readFile } = require('fs').promises + +const bundleResourceToFile = (inPath, outPath) => { + return new Promise((resolve, reject) => { + browserify(inPath).bundle() + .pipe(fs.createWriteStream(outPath)) + .once('finish', () => resolve()) + .once('error', (e) => reject(e)) + }) +} + +const bundleResource = (inPath) => { + return new Promise((resolve, reject) => { + browserify(inPath).bundle((err, buffer) => { + if (err != null) { + reject(err) + return + } + + resolve(buffer) + }) + }) +} + +const main = async () => { + if (process.argv[2] === 'build') { + await bundleResourceToFile('client/main.js', 'static/karma.js') + await bundleResourceToFile('context/main.js', 'static/context.js') + } else if (process.argv[2] === 'check') { + const expectedClient = await bundleResource('client/main.js') + const expectedContext = await bundleResource('context/main.js') + + const actualClient = await readFile('static/karma.js') + const actualContext = await readFile('static/context.js') + + if (Buffer.compare(expectedClient, actualClient) !== 0 || Buffer.compare(expectedContext, actualContext) !== 0) { + // eslint-disable-next-line no-throw-literal + throw 'Bundled client assets are outdated. Forgot to run "npm run build"?' + } + } else { + // eslint-disable-next-line no-throw-literal + throw `Unknown command: ${process.argv[2]}` + } +} + +main().catch((err) => { + console.error(err) + process.exit(1) +}) diff --git a/static/context.js b/static/context.js new file mode 100644 index 000000000..8cc67ebf6 --- /dev/null +++ b/static/context.js @@ -0,0 +1,2645 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i function abc(a, b, c) { ... } + return obj.toString().replace(/\{[\s\S]*\}/, '{ ... }') + } catch (err) { + if (err instanceof TypeError) { + // Support older browsers + return 'function ' + (obj.name || '') + '() { ... }' + } else { + throw err + } + } + case 'boolean': + return obj ? 'true' : 'false' + case 'object': + var strs = [] + if (instanceOf(obj, 'Array')) { + strs.push('[') + for (var i = 0, ii = obj.length; i < ii; i++) { + if (i) { + strs.push(', ') + } + strs.push(stringify(obj[i], depth - 1)) + } + strs.push(']') + } else if (instanceOf(obj, 'Date')) { + return obj.toString() + } else if (instanceOf(obj, 'Text')) { + return obj.nodeValue + } else if (instanceOf(obj, 'Comment')) { + return '' + } else if (obj.outerHTML) { + return obj.outerHTML + } else if (isNode(obj)) { + if (serialize) { + return serialize(obj) + } else { + return 'Skipping stringify, no support for dom-serialize' + } + } else if (instanceOf(obj, 'Error')) { + return obj.toString() + '\n' + obj.stack + } else { + var constructor = 'Object' + if (obj.constructor && typeof obj.constructor === 'function') { + constructor = obj.constructor.name + } + + strs.push(constructor) + strs.push('{') + var first = true + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + if (first) { + first = false + } else { + strs.push(', ') + } + + strs.push(key + ': ' + stringify(obj[key], depth - 1)) + } + } + strs.push('}') + } + return strs.join('') + default: + return obj + } +} + +module.exports = stringify + +},{"./util":2,"dom-serialize":6}],2:[function(require,module,exports){ +exports.instanceOf = function (value, constructorName) { + return Object.prototype.toString.apply(value) === '[object ' + constructorName + ']' +} + +exports.elm = function (id) { + return document.getElementById(id) +} + +exports.generateId = function (prefix) { + return prefix + Math.floor(Math.random() * 10000) +} + +exports.isUndefined = function (value) { + return typeof value === 'undefined' +} + +exports.isDefined = function (value) { + return !exports.isUndefined(value) +} + +exports.parseQueryParams = function (locationSearch) { + var params = {} + var pairs = locationSearch.substr(1).split('&') + var keyValue + + for (var i = 0; i < pairs.length; i++) { + keyValue = pairs[i].split('=') + params[decodeURIComponent(keyValue[0])] = decodeURIComponent(keyValue[1]) + } + + return params +} + +},{}],3:[function(require,module,exports){ +// Load our dependencies +var stringify = require('../common/stringify') + +// Define our context Karma constructor +function ContextKarma (callParentKarmaMethod) { + // Define local variables + var hasError = false + var self = this + var isLoaded = false + + // Define our loggers + // DEV: These are intentionally repeated in client and context + this.log = function (type, args) { + var values = [] + + for (var i = 0; i < args.length; i++) { + values.push(this.stringify(args[i], 3)) + } + + this.info({ log: values.join(', '), type: type }) + } + + this.stringify = stringify + + // Define our proxy error handler + // DEV: We require one in our context to track `hasError` + this.error = function () { + hasError = true + callParentKarmaMethod('error', [].slice.call(arguments)) + return false + } + + // Define our start handler + function UNIMPLEMENTED_START () { + this.error('You need to include some adapter that implements __karma__.start method!') + } + // all files loaded, let's start the execution + this.loaded = function () { + // has error -> cancel + if (!hasError && !isLoaded) { + isLoaded = true + try { + this.start(this.config) + } catch (error) { + this.error(error.stack || error.toString()) + } + } + + // remove reference to child iframe + this.start = UNIMPLEMENTED_START + } + // supposed to be overridden by the context + // TODO(vojta): support multiple callbacks (queue) + this.start = UNIMPLEMENTED_START + + // Define proxy methods + // DEV: This is a closured `for` loop (same as a `forEach`) for IE support + var proxyMethods = ['complete', 'info', 'result'] + for (var i = 0; i < proxyMethods.length; i++) { + (function bindProxyMethod (methodName) { + self[methodName] = function boundProxyMethod () { + callParentKarmaMethod(methodName, [].slice.call(arguments)) + } + }(proxyMethods[i])) + } + + // Define bindings for context window + this.setupContext = function (contextWindow) { + // If we clear the context after every run and we already had an error + // then stop now. Otherwise, carry on. + if (self.config.clearContext && hasError) { + return + } + + // Perform window level bindings + // DEV: We return `self.error` since we want to `return false` to ignore errors + contextWindow.onerror = function () { + return self.error.apply(self, arguments) + } + // DEV: We must defined a function since we don't want to pass the event object + contextWindow.onbeforeunload = function (e, b) { + callParentKarmaMethod('onbeforeunload', []) + } + + contextWindow.dump = function () { + self.log('dump', arguments) + } + + var _confirm = contextWindow.confirm + var _prompt = contextWindow.prompt + + contextWindow.alert = function (msg) { + self.log('alert', [msg]) + } + + contextWindow.confirm = function (msg) { + self.log('confirm', [msg]) + return _confirm(msg) + } + + contextWindow.prompt = function (msg, defaultVal) { + self.log('prompt', [msg, defaultVal]) + return _prompt(msg, defaultVal) + } + + // If we want to overload our console, then do it + function getConsole (currentWindow) { + return currentWindow.console || { + log: function () {}, + info: function () {}, + warn: function () {}, + error: function () {}, + debug: function () {} + } + } + if (self.config.captureConsole) { + // patch the console + var localConsole = contextWindow.console = getConsole(contextWindow) + var logMethods = ['log', 'info', 'warn', 'error', 'debug'] + var patchConsoleMethod = function (method) { + var orig = localConsole[method] + if (!orig) { + return + } + localConsole[method] = function () { + self.log(method, arguments) + try { + return Function.prototype.apply.call(orig, localConsole, arguments) + } catch (error) { + self.log('warn', ['Console method ' + method + ' threw: ' + error]) + } + } + } + for (var i = 0; i < logMethods.length; i++) { + patchConsoleMethod(logMethods[i]) + } + } + } +} + +// Define call/proxy methods +ContextKarma.getDirectCallParentKarmaMethod = function (parentWindow) { + return function directCallParentKarmaMethod (method, args) { + // If the method doesn't exist, then error out + if (!parentWindow.karma[method]) { + parentWindow.karma.error('Expected Karma method "' + method + '" to exist but it doesn\'t') + return + } + + // Otherwise, run our method + parentWindow.karma[method].apply(parentWindow.karma, args) + } +} +ContextKarma.getPostMessageCallParentKarmaMethod = function (parentWindow) { + return function postMessageCallParentKarmaMethod (method, args) { + parentWindow.postMessage({ __karmaMethod: method, __karmaArguments: args }, window.location.origin) + } +} + +// Export our module +module.exports = ContextKarma + +},{"../common/stringify":1}],4:[function(require,module,exports){ +// Load in our dependencies +var ContextKarma = require('./karma') + +// Resolve our parent window +var parentWindow = window.opener || window.parent + +// Define a remote call method for Karma +var callParentKarmaMethod = ContextKarma.getDirectCallParentKarmaMethod(parentWindow) + +// If we don't have access to the window, then use `postMessage` +// DEV: In Electron, we don't have access to the parent window due to it being in a separate process +// DEV: We avoid using this in Internet Explorer as they only support strings +// http://caniuse.com/#search=postmessage +var haveParentAccess = false +try { haveParentAccess = !!parentWindow.window } catch (err) { /* Ignore errors (likely permisison errors) */ } +if (!haveParentAccess) { + callParentKarmaMethod = ContextKarma.getPostMessageCallParentKarmaMethod(parentWindow) +} + +// Define a window-scoped Karma +window.__karma__ = new ContextKarma(callParentKarmaMethod) + +},{"./karma":3}],5:[function(require,module,exports){ +(function (global){ + +var NativeCustomEvent = global.CustomEvent; + +function useNative () { + try { + var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } }); + return 'cat' === p.type && 'bar' === p.detail.foo; + } catch (e) { + } + return false; +} + +/** + * Cross-browser `CustomEvent` constructor. + * + * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent + * + * @public + */ + +module.exports = useNative() ? NativeCustomEvent : + +// IE >= 9 +'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) { + var e = document.createEvent('CustomEvent'); + if (params) { + e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail); + } else { + e.initCustomEvent(type, false, false, void 0); + } + return e; +} : + +// IE <= 8 +function CustomEvent (type, params) { + var e = document.createEventObject(); + e.type = type; + if (params) { + e.bubbles = Boolean(params.bubbles); + e.cancelable = Boolean(params.cancelable); + e.detail = params.detail; + } else { + e.bubbles = false; + e.cancelable = false; + e.detail = void 0; + } + return e; +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],6:[function(require,module,exports){ + +/** + * Module dependencies. + */ + +var extend = require('extend'); +var encode = require('ent/encode'); +var CustomEvent = require('custom-event'); +var voidElements = require('void-elements'); + +/** + * Module exports. + */ + +exports = module.exports = serialize; +exports.serializeElement = serializeElement; +exports.serializeAttribute = serializeAttribute; +exports.serializeText = serializeText; +exports.serializeComment = serializeComment; +exports.serializeDocument = serializeDocument; +exports.serializeDoctype = serializeDoctype; +exports.serializeDocumentFragment = serializeDocumentFragment; +exports.serializeNodeList = serializeNodeList; + +/** + * Serializes any DOM node. Returns a string. + * + * @param {Node} node - DOM Node to serialize + * @param {String} [context] - optional arbitrary "context" string to use (useful for event listeners) + * @param {Function} [fn] - optional callback function to use in the "serialize" event for this call + * @param {EventTarget} [eventTarget] - optional EventTarget instance to emit the "serialize" event on (defaults to `node`) + * return {String} + * @public + */ + +function serialize (node, context, fn, eventTarget) { + if (!node) return ''; + if ('function' === typeof context) { + fn = context; + context = null; + } + if (!context) context = null; + + var rtn; + var nodeType = node.nodeType; + + if (!nodeType && 'number' === typeof node.length) { + // assume it's a NodeList or Array of Nodes + rtn = exports.serializeNodeList(node, context, fn); + } else { + + if ('function' === typeof fn) { + // one-time "serialize" event listener + node.addEventListener('serialize', fn, false); + } + + // emit a custom "serialize" event on `node`, in case there + // are event listeners for custom serialization of this node + var e = new CustomEvent('serialize', { + bubbles: true, + cancelable: true, + detail: { + serialize: null, + context: context + } + }); + + e.serializeTarget = node; + + var target = eventTarget || node; + var cancelled = !target.dispatchEvent(e); + + // `e.detail.serialize` can be set to a: + // String - returned directly + // Node - goes through serializer logic instead of `node` + // Anything else - get Stringified first, and then returned directly + var s = e.detail.serialize; + if (s != null) { + if ('string' === typeof s) { + rtn = s; + } else if ('number' === typeof s.nodeType) { + // make it go through the serialization logic + rtn = serialize(s, context, null, target); + } else { + rtn = String(s); + } + } else if (!cancelled) { + // default serialization logic + switch (nodeType) { + case 1 /* element */: + rtn = exports.serializeElement(node, context, eventTarget); + break; + case 2 /* attribute */: + rtn = exports.serializeAttribute(node); + break; + case 3 /* text */: + rtn = exports.serializeText(node); + break; + case 8 /* comment */: + rtn = exports.serializeComment(node); + break; + case 9 /* document */: + rtn = exports.serializeDocument(node, context, eventTarget); + break; + case 10 /* doctype */: + rtn = exports.serializeDoctype(node); + break; + case 11 /* document fragment */: + rtn = exports.serializeDocumentFragment(node, context, eventTarget); + break; + } + } + + if ('function' === typeof fn) { + node.removeEventListener('serialize', fn, false); + } + } + + return rtn || ''; +} + +/** + * Serialize an Attribute node. + */ + +function serializeAttribute (node, opts) { + return node.name + '="' + encode(node.value, extend({ + named: true + }, opts)) + '"'; +} + +/** + * Serialize a DOM element. + */ + +function serializeElement (node, context, eventTarget) { + var c, i, l; + var name = node.nodeName.toLowerCase(); + + // opening tag + var r = '<' + name; + + // attributes + for (i = 0, c = node.attributes, l = c.length; i < l; i++) { + r += ' ' + exports.serializeAttribute(c[i]); + } + + r += '>'; + + // child nodes + r += exports.serializeNodeList(node.childNodes, context, null, eventTarget); + + // closing tag, only for non-void elements + if (!voidElements[name]) { + r += ''; + } + + return r; +} + +/** + * Serialize a text node. + */ + +function serializeText (node, opts) { + return encode(node.nodeValue, extend({ + named: true, + special: { '<': true, '>': true, '&': true } + }, opts)); +} + +/** + * Serialize a comment node. + */ + +function serializeComment (node) { + return ''; +} + +/** + * Serialize a Document node. + */ + +function serializeDocument (node, context, eventTarget) { + return exports.serializeNodeList(node.childNodes, context, null, eventTarget); +} + +/** + * Serialize a DOCTYPE node. + * See: http://stackoverflow.com/a/10162353 + */ + +function serializeDoctype (node) { + var r = ''; + return r; +} + +/** + * Serialize a DocumentFragment instance. + */ + +function serializeDocumentFragment (node, context, eventTarget) { + return exports.serializeNodeList(node.childNodes, context, null, eventTarget); +} + +/** + * Serialize a NodeList/Array of nodes. + */ + +function serializeNodeList (list, context, fn, eventTarget) { + var r = ''; + for (var i = 0, l = list.length; i < l; i++) { + r += serialize(list[i], context, fn, eventTarget); + } + return r; +} + +},{"custom-event":5,"ent/encode":7,"extend":9,"void-elements":11}],7:[function(require,module,exports){ +var punycode = require('punycode'); +var revEntities = require('./reversed.json'); + +module.exports = encode; + +function encode (str, opts) { + if (typeof str !== 'string') { + throw new TypeError('Expected a String'); + } + if (!opts) opts = {}; + + var numeric = true; + if (opts.named) numeric = false; + if (opts.numeric !== undefined) numeric = opts.numeric; + + var special = opts.special || { + '"': true, "'": true, + '<': true, '>': true, + '&': true + }; + + var codePoints = punycode.ucs2.decode(str); + var chars = []; + for (var i = 0; i < codePoints.length; i++) { + var cc = codePoints[i]; + var c = punycode.ucs2.encode([ cc ]); + var e = revEntities[cc]; + if (e && (cc >= 127 || special[c]) && !numeric) { + chars.push('&' + (/;$/.test(e) ? e : e + ';')); + } + else if (cc < 32 || cc >= 127 || special[c]) { + chars.push('&#' + cc + ';'); + } + else { + chars.push(c); + } + } + return chars.join(''); +} + +},{"./reversed.json":8,"punycode":10}],8:[function(require,module,exports){ +module.exports={ + "9": "Tab;", + "10": "NewLine;", + "33": "excl;", + "34": "quot;", + "35": "num;", + "36": "dollar;", + "37": "percnt;", + "38": "amp;", + "39": "apos;", + "40": "lpar;", + "41": "rpar;", + "42": "midast;", + "43": "plus;", + "44": "comma;", + "46": "period;", + "47": "sol;", + "58": "colon;", + "59": "semi;", + "60": "lt;", + "61": "equals;", + "62": "gt;", + "63": "quest;", + "64": "commat;", + "91": "lsqb;", + "92": "bsol;", + "93": "rsqb;", + "94": "Hat;", + "95": "UnderBar;", + "96": "grave;", + "123": "lcub;", + "124": "VerticalLine;", + "125": "rcub;", + "160": "NonBreakingSpace;", + "161": "iexcl;", + "162": "cent;", + "163": "pound;", + "164": "curren;", + "165": "yen;", + "166": "brvbar;", + "167": "sect;", + "168": "uml;", + "169": "copy;", + "170": "ordf;", + "171": "laquo;", + "172": "not;", + "173": "shy;", + "174": "reg;", + "175": "strns;", + "176": "deg;", + "177": "pm;", + "178": "sup2;", + "179": "sup3;", + "180": "DiacriticalAcute;", + "181": "micro;", + "182": "para;", + "183": "middot;", + "184": "Cedilla;", + "185": "sup1;", + "186": "ordm;", + "187": "raquo;", + "188": "frac14;", + "189": "half;", + "190": "frac34;", + "191": "iquest;", + "192": "Agrave;", + "193": "Aacute;", + "194": "Acirc;", + "195": "Atilde;", + "196": "Auml;", + "197": "Aring;", + "198": "AElig;", + "199": "Ccedil;", + "200": "Egrave;", + "201": "Eacute;", + "202": "Ecirc;", + "203": "Euml;", + "204": "Igrave;", + "205": "Iacute;", + "206": "Icirc;", + "207": "Iuml;", + "208": "ETH;", + "209": "Ntilde;", + "210": "Ograve;", + "211": "Oacute;", + "212": "Ocirc;", + "213": "Otilde;", + "214": "Ouml;", + "215": "times;", + "216": "Oslash;", + "217": "Ugrave;", + "218": "Uacute;", + "219": "Ucirc;", + "220": "Uuml;", + "221": "Yacute;", + "222": "THORN;", + "223": "szlig;", + "224": "agrave;", + "225": "aacute;", + "226": "acirc;", + "227": "atilde;", + "228": "auml;", + "229": "aring;", + "230": "aelig;", + "231": "ccedil;", + "232": "egrave;", + "233": "eacute;", + "234": "ecirc;", + "235": "euml;", + "236": "igrave;", + "237": "iacute;", + "238": "icirc;", + "239": "iuml;", + "240": "eth;", + "241": "ntilde;", + "242": "ograve;", + "243": "oacute;", + "244": "ocirc;", + "245": "otilde;", + "246": "ouml;", + "247": "divide;", + "248": "oslash;", + "249": "ugrave;", + "250": "uacute;", + "251": "ucirc;", + "252": "uuml;", + "253": "yacute;", + "254": "thorn;", + "255": "yuml;", + "256": "Amacr;", + "257": "amacr;", + "258": "Abreve;", + "259": "abreve;", + "260": "Aogon;", + "261": "aogon;", + "262": "Cacute;", + "263": "cacute;", + "264": "Ccirc;", + "265": "ccirc;", + "266": "Cdot;", + "267": "cdot;", + "268": "Ccaron;", + "269": "ccaron;", + "270": "Dcaron;", + "271": "dcaron;", + "272": "Dstrok;", + "273": "dstrok;", + "274": "Emacr;", + "275": "emacr;", + "278": "Edot;", + "279": "edot;", + "280": "Eogon;", + "281": "eogon;", + "282": "Ecaron;", + "283": "ecaron;", + "284": "Gcirc;", + "285": "gcirc;", + "286": "Gbreve;", + "287": "gbreve;", + "288": "Gdot;", + "289": "gdot;", + "290": "Gcedil;", + "292": "Hcirc;", + "293": "hcirc;", + "294": "Hstrok;", + "295": "hstrok;", + "296": "Itilde;", + "297": "itilde;", + "298": "Imacr;", + "299": "imacr;", + "302": "Iogon;", + "303": "iogon;", + "304": "Idot;", + "305": "inodot;", + "306": "IJlig;", + "307": "ijlig;", + "308": "Jcirc;", + "309": "jcirc;", + "310": "Kcedil;", + "311": "kcedil;", + "312": "kgreen;", + "313": "Lacute;", + "314": "lacute;", + "315": "Lcedil;", + "316": "lcedil;", + "317": "Lcaron;", + "318": "lcaron;", + "319": "Lmidot;", + "320": "lmidot;", + "321": "Lstrok;", + "322": "lstrok;", + "323": "Nacute;", + "324": "nacute;", + "325": "Ncedil;", + "326": "ncedil;", + "327": "Ncaron;", + "328": "ncaron;", + "329": "napos;", + "330": "ENG;", + "331": "eng;", + "332": "Omacr;", + "333": "omacr;", + "336": "Odblac;", + "337": "odblac;", + "338": "OElig;", + "339": "oelig;", + "340": "Racute;", + "341": "racute;", + "342": "Rcedil;", + "343": "rcedil;", + "344": "Rcaron;", + "345": "rcaron;", + "346": "Sacute;", + "347": "sacute;", + "348": "Scirc;", + "349": "scirc;", + "350": "Scedil;", + "351": "scedil;", + "352": "Scaron;", + "353": "scaron;", + "354": "Tcedil;", + "355": "tcedil;", + "356": "Tcaron;", + "357": "tcaron;", + "358": "Tstrok;", + "359": "tstrok;", + "360": "Utilde;", + "361": "utilde;", + "362": "Umacr;", + "363": "umacr;", + "364": "Ubreve;", + "365": "ubreve;", + "366": "Uring;", + "367": "uring;", + "368": "Udblac;", + "369": "udblac;", + "370": "Uogon;", + "371": "uogon;", + "372": "Wcirc;", + "373": "wcirc;", + "374": "Ycirc;", + "375": "ycirc;", + "376": "Yuml;", + "377": "Zacute;", + "378": "zacute;", + "379": "Zdot;", + "380": "zdot;", + "381": "Zcaron;", + "382": "zcaron;", + "402": "fnof;", + "437": "imped;", + "501": "gacute;", + "567": "jmath;", + "710": "circ;", + "711": "Hacek;", + "728": "breve;", + "729": "dot;", + "730": "ring;", + "731": "ogon;", + "732": "tilde;", + "733": "DiacriticalDoubleAcute;", + "785": "DownBreve;", + "913": "Alpha;", + "914": "Beta;", + "915": "Gamma;", + "916": "Delta;", + "917": "Epsilon;", + "918": "Zeta;", + "919": "Eta;", + "920": "Theta;", + "921": "Iota;", + "922": "Kappa;", + "923": "Lambda;", + "924": "Mu;", + "925": "Nu;", + "926": "Xi;", + "927": "Omicron;", + "928": "Pi;", + "929": "Rho;", + "931": "Sigma;", + "932": "Tau;", + "933": "Upsilon;", + "934": "Phi;", + "935": "Chi;", + "936": "Psi;", + "937": "Omega;", + "945": "alpha;", + "946": "beta;", + "947": "gamma;", + "948": "delta;", + "949": "epsilon;", + "950": "zeta;", + "951": "eta;", + "952": "theta;", + "953": "iota;", + "954": "kappa;", + "955": "lambda;", + "956": "mu;", + "957": "nu;", + "958": "xi;", + "959": "omicron;", + "960": "pi;", + "961": "rho;", + "962": "varsigma;", + "963": "sigma;", + "964": "tau;", + "965": "upsilon;", + "966": "phi;", + "967": "chi;", + "968": "psi;", + "969": "omega;", + "977": "vartheta;", + "978": "upsih;", + "981": "varphi;", + "982": "varpi;", + "988": "Gammad;", + "989": "gammad;", + "1008": "varkappa;", + "1009": "varrho;", + "1013": "varepsilon;", + "1014": "bepsi;", + "1025": "IOcy;", + "1026": "DJcy;", + "1027": "GJcy;", + "1028": "Jukcy;", + "1029": "DScy;", + "1030": "Iukcy;", + "1031": "YIcy;", + "1032": "Jsercy;", + "1033": "LJcy;", + "1034": "NJcy;", + "1035": "TSHcy;", + "1036": "KJcy;", + "1038": "Ubrcy;", + "1039": "DZcy;", + "1040": "Acy;", + "1041": "Bcy;", + "1042": "Vcy;", + "1043": "Gcy;", + "1044": "Dcy;", + "1045": "IEcy;", + "1046": "ZHcy;", + "1047": "Zcy;", + "1048": "Icy;", + "1049": "Jcy;", + "1050": "Kcy;", + "1051": "Lcy;", + "1052": "Mcy;", + "1053": "Ncy;", + "1054": "Ocy;", + "1055": "Pcy;", + "1056": "Rcy;", + "1057": "Scy;", + "1058": "Tcy;", + "1059": "Ucy;", + "1060": "Fcy;", + "1061": "KHcy;", + "1062": "TScy;", + "1063": "CHcy;", + "1064": "SHcy;", + "1065": "SHCHcy;", + "1066": "HARDcy;", + "1067": "Ycy;", + "1068": "SOFTcy;", + "1069": "Ecy;", + "1070": "YUcy;", + "1071": "YAcy;", + "1072": "acy;", + "1073": "bcy;", + "1074": "vcy;", + "1075": "gcy;", + "1076": "dcy;", + "1077": "iecy;", + "1078": "zhcy;", + "1079": "zcy;", + "1080": "icy;", + "1081": "jcy;", + "1082": "kcy;", + "1083": "lcy;", + "1084": "mcy;", + "1085": "ncy;", + "1086": "ocy;", + "1087": "pcy;", + "1088": "rcy;", + "1089": "scy;", + "1090": "tcy;", + "1091": "ucy;", + "1092": "fcy;", + "1093": "khcy;", + "1094": "tscy;", + "1095": "chcy;", + "1096": "shcy;", + "1097": "shchcy;", + "1098": "hardcy;", + "1099": "ycy;", + "1100": "softcy;", + "1101": "ecy;", + "1102": "yucy;", + "1103": "yacy;", + "1105": "iocy;", + "1106": "djcy;", + "1107": "gjcy;", + "1108": "jukcy;", + "1109": "dscy;", + "1110": "iukcy;", + "1111": "yicy;", + "1112": "jsercy;", + "1113": "ljcy;", + "1114": "njcy;", + "1115": "tshcy;", + "1116": "kjcy;", + "1118": "ubrcy;", + "1119": "dzcy;", + "8194": "ensp;", + "8195": "emsp;", + "8196": "emsp13;", + "8197": "emsp14;", + "8199": "numsp;", + "8200": "puncsp;", + "8201": "ThinSpace;", + "8202": "VeryThinSpace;", + "8203": "ZeroWidthSpace;", + "8204": "zwnj;", + "8205": "zwj;", + "8206": "lrm;", + "8207": "rlm;", + "8208": "hyphen;", + "8211": "ndash;", + "8212": "mdash;", + "8213": "horbar;", + "8214": "Vert;", + "8216": "OpenCurlyQuote;", + "8217": "rsquor;", + "8218": "sbquo;", + "8220": "OpenCurlyDoubleQuote;", + "8221": "rdquor;", + "8222": "ldquor;", + "8224": "dagger;", + "8225": "ddagger;", + "8226": "bullet;", + "8229": "nldr;", + "8230": "mldr;", + "8240": "permil;", + "8241": "pertenk;", + "8242": "prime;", + "8243": "Prime;", + "8244": "tprime;", + "8245": "bprime;", + "8249": "lsaquo;", + "8250": "rsaquo;", + "8254": "OverBar;", + "8257": "caret;", + "8259": "hybull;", + "8260": "frasl;", + "8271": "bsemi;", + "8279": "qprime;", + "8287": "MediumSpace;", + "8288": "NoBreak;", + "8289": "ApplyFunction;", + "8290": "it;", + "8291": "InvisibleComma;", + "8364": "euro;", + "8411": "TripleDot;", + "8412": "DotDot;", + "8450": "Copf;", + "8453": "incare;", + "8458": "gscr;", + "8459": "Hscr;", + "8460": "Poincareplane;", + "8461": "quaternions;", + "8462": "planckh;", + "8463": "plankv;", + "8464": "Iscr;", + "8465": "imagpart;", + "8466": "Lscr;", + "8467": "ell;", + "8469": "Nopf;", + "8470": "numero;", + "8471": "copysr;", + "8472": "wp;", + "8473": "primes;", + "8474": "rationals;", + "8475": "Rscr;", + "8476": "Rfr;", + "8477": "Ropf;", + "8478": "rx;", + "8482": "trade;", + "8484": "Zopf;", + "8487": "mho;", + "8488": "Zfr;", + "8489": "iiota;", + "8492": "Bscr;", + "8493": "Cfr;", + "8495": "escr;", + "8496": "expectation;", + "8497": "Fscr;", + "8499": "phmmat;", + "8500": "oscr;", + "8501": "aleph;", + "8502": "beth;", + "8503": "gimel;", + "8504": "daleth;", + "8517": "DD;", + "8518": "DifferentialD;", + "8519": "exponentiale;", + "8520": "ImaginaryI;", + "8531": "frac13;", + "8532": "frac23;", + "8533": "frac15;", + "8534": "frac25;", + "8535": "frac35;", + "8536": "frac45;", + "8537": "frac16;", + "8538": "frac56;", + "8539": "frac18;", + "8540": "frac38;", + "8541": "frac58;", + "8542": "frac78;", + "8592": "slarr;", + "8593": "uparrow;", + "8594": "srarr;", + "8595": "ShortDownArrow;", + "8596": "leftrightarrow;", + "8597": "varr;", + "8598": "UpperLeftArrow;", + "8599": "UpperRightArrow;", + "8600": "searrow;", + "8601": "swarrow;", + "8602": "nleftarrow;", + "8603": "nrightarrow;", + "8605": "rightsquigarrow;", + "8606": "twoheadleftarrow;", + "8607": "Uarr;", + "8608": "twoheadrightarrow;", + "8609": "Darr;", + "8610": "leftarrowtail;", + "8611": "rightarrowtail;", + "8612": "mapstoleft;", + "8613": "UpTeeArrow;", + "8614": "RightTeeArrow;", + "8615": "mapstodown;", + "8617": "larrhk;", + "8618": "rarrhk;", + "8619": "looparrowleft;", + "8620": "rarrlp;", + "8621": "leftrightsquigarrow;", + "8622": "nleftrightarrow;", + "8624": "lsh;", + "8625": "rsh;", + "8626": "ldsh;", + "8627": "rdsh;", + "8629": "crarr;", + "8630": "curvearrowleft;", + "8631": "curvearrowright;", + "8634": "olarr;", + "8635": "orarr;", + "8636": "lharu;", + "8637": "lhard;", + "8638": "upharpoonright;", + "8639": "upharpoonleft;", + "8640": "RightVector;", + "8641": "rightharpoondown;", + "8642": "RightDownVector;", + "8643": "LeftDownVector;", + "8644": "rlarr;", + "8645": "UpArrowDownArrow;", + "8646": "lrarr;", + "8647": "llarr;", + "8648": "uuarr;", + "8649": "rrarr;", + "8650": "downdownarrows;", + "8651": "ReverseEquilibrium;", + "8652": "rlhar;", + "8653": "nLeftarrow;", + "8654": "nLeftrightarrow;", + "8655": "nRightarrow;", + "8656": "Leftarrow;", + "8657": "Uparrow;", + "8658": "Rightarrow;", + "8659": "Downarrow;", + "8660": "Leftrightarrow;", + "8661": "vArr;", + "8662": "nwArr;", + "8663": "neArr;", + "8664": "seArr;", + "8665": "swArr;", + "8666": "Lleftarrow;", + "8667": "Rrightarrow;", + "8669": "zigrarr;", + "8676": "LeftArrowBar;", + "8677": "RightArrowBar;", + "8693": "duarr;", + "8701": "loarr;", + "8702": "roarr;", + "8703": "hoarr;", + "8704": "forall;", + "8705": "complement;", + "8706": "PartialD;", + "8707": "Exists;", + "8708": "NotExists;", + "8709": "varnothing;", + "8711": "nabla;", + "8712": "isinv;", + "8713": "notinva;", + "8715": "SuchThat;", + "8716": "NotReverseElement;", + "8719": "Product;", + "8720": "Coproduct;", + "8721": "sum;", + "8722": "minus;", + "8723": "mp;", + "8724": "plusdo;", + "8726": "ssetmn;", + "8727": "lowast;", + "8728": "SmallCircle;", + "8730": "Sqrt;", + "8733": "vprop;", + "8734": "infin;", + "8735": "angrt;", + "8736": "angle;", + "8737": "measuredangle;", + "8738": "angsph;", + "8739": "VerticalBar;", + "8740": "nsmid;", + "8741": "spar;", + "8742": "nspar;", + "8743": "wedge;", + "8744": "vee;", + "8745": "cap;", + "8746": "cup;", + "8747": "Integral;", + "8748": "Int;", + "8749": "tint;", + "8750": "oint;", + "8751": "DoubleContourIntegral;", + "8752": "Cconint;", + "8753": "cwint;", + "8754": "cwconint;", + "8755": "CounterClockwiseContourIntegral;", + "8756": "therefore;", + "8757": "because;", + "8758": "ratio;", + "8759": "Proportion;", + "8760": "minusd;", + "8762": "mDDot;", + "8763": "homtht;", + "8764": "Tilde;", + "8765": "bsim;", + "8766": "mstpos;", + "8767": "acd;", + "8768": "wreath;", + "8769": "nsim;", + "8770": "esim;", + "8771": "TildeEqual;", + "8772": "nsimeq;", + "8773": "TildeFullEqual;", + "8774": "simne;", + "8775": "NotTildeFullEqual;", + "8776": "TildeTilde;", + "8777": "NotTildeTilde;", + "8778": "approxeq;", + "8779": "apid;", + "8780": "bcong;", + "8781": "CupCap;", + "8782": "HumpDownHump;", + "8783": "HumpEqual;", + "8784": "esdot;", + "8785": "eDot;", + "8786": "fallingdotseq;", + "8787": "risingdotseq;", + "8788": "coloneq;", + "8789": "eqcolon;", + "8790": "eqcirc;", + "8791": "cire;", + "8793": "wedgeq;", + "8794": "veeeq;", + "8796": "trie;", + "8799": "questeq;", + "8800": "NotEqual;", + "8801": "equiv;", + "8802": "NotCongruent;", + "8804": "leq;", + "8805": "GreaterEqual;", + "8806": "LessFullEqual;", + "8807": "GreaterFullEqual;", + "8808": "lneqq;", + "8809": "gneqq;", + "8810": "NestedLessLess;", + "8811": "NestedGreaterGreater;", + "8812": "twixt;", + "8813": "NotCupCap;", + "8814": "NotLess;", + "8815": "NotGreater;", + "8816": "NotLessEqual;", + "8817": "NotGreaterEqual;", + "8818": "lsim;", + "8819": "gtrsim;", + "8820": "NotLessTilde;", + "8821": "NotGreaterTilde;", + "8822": "lg;", + "8823": "gtrless;", + "8824": "ntlg;", + "8825": "ntgl;", + "8826": "Precedes;", + "8827": "Succeeds;", + "8828": "PrecedesSlantEqual;", + "8829": "SucceedsSlantEqual;", + "8830": "prsim;", + "8831": "succsim;", + "8832": "nprec;", + "8833": "nsucc;", + "8834": "subset;", + "8835": "supset;", + "8836": "nsub;", + "8837": "nsup;", + "8838": "SubsetEqual;", + "8839": "supseteq;", + "8840": "nsubseteq;", + "8841": "nsupseteq;", + "8842": "subsetneq;", + "8843": "supsetneq;", + "8845": "cupdot;", + "8846": "uplus;", + "8847": "SquareSubset;", + "8848": "SquareSuperset;", + "8849": "SquareSubsetEqual;", + "8850": "SquareSupersetEqual;", + "8851": "SquareIntersection;", + "8852": "SquareUnion;", + "8853": "oplus;", + "8854": "ominus;", + "8855": "otimes;", + "8856": "osol;", + "8857": "odot;", + "8858": "ocir;", + "8859": "oast;", + "8861": "odash;", + "8862": "plusb;", + "8863": "minusb;", + "8864": "timesb;", + "8865": "sdotb;", + "8866": "vdash;", + "8867": "LeftTee;", + "8868": "top;", + "8869": "UpTee;", + "8871": "models;", + "8872": "vDash;", + "8873": "Vdash;", + "8874": "Vvdash;", + "8875": "VDash;", + "8876": "nvdash;", + "8877": "nvDash;", + "8878": "nVdash;", + "8879": "nVDash;", + "8880": "prurel;", + "8882": "vltri;", + "8883": "vrtri;", + "8884": "trianglelefteq;", + "8885": "trianglerighteq;", + "8886": "origof;", + "8887": "imof;", + "8888": "mumap;", + "8889": "hercon;", + "8890": "intercal;", + "8891": "veebar;", + "8893": "barvee;", + "8894": "angrtvb;", + "8895": "lrtri;", + "8896": "xwedge;", + "8897": "xvee;", + "8898": "xcap;", + "8899": "xcup;", + "8900": "diamond;", + "8901": "sdot;", + "8902": "Star;", + "8903": "divonx;", + "8904": "bowtie;", + "8905": "ltimes;", + "8906": "rtimes;", + "8907": "lthree;", + "8908": "rthree;", + "8909": "bsime;", + "8910": "cuvee;", + "8911": "cuwed;", + "8912": "Subset;", + "8913": "Supset;", + "8914": "Cap;", + "8915": "Cup;", + "8916": "pitchfork;", + "8917": "epar;", + "8918": "ltdot;", + "8919": "gtrdot;", + "8920": "Ll;", + "8921": "ggg;", + "8922": "LessEqualGreater;", + "8923": "gtreqless;", + "8926": "curlyeqprec;", + "8927": "curlyeqsucc;", + "8928": "nprcue;", + "8929": "nsccue;", + "8930": "nsqsube;", + "8931": "nsqsupe;", + "8934": "lnsim;", + "8935": "gnsim;", + "8936": "prnsim;", + "8937": "succnsim;", + "8938": "ntriangleleft;", + "8939": "ntriangleright;", + "8940": "ntrianglelefteq;", + "8941": "ntrianglerighteq;", + "8942": "vellip;", + "8943": "ctdot;", + "8944": "utdot;", + "8945": "dtdot;", + "8946": "disin;", + "8947": "isinsv;", + "8948": "isins;", + "8949": "isindot;", + "8950": "notinvc;", + "8951": "notinvb;", + "8953": "isinE;", + "8954": "nisd;", + "8955": "xnis;", + "8956": "nis;", + "8957": "notnivc;", + "8958": "notnivb;", + "8965": "barwedge;", + "8966": "doublebarwedge;", + "8968": "LeftCeiling;", + "8969": "RightCeiling;", + "8970": "lfloor;", + "8971": "RightFloor;", + "8972": "drcrop;", + "8973": "dlcrop;", + "8974": "urcrop;", + "8975": "ulcrop;", + "8976": "bnot;", + "8978": "profline;", + "8979": "profsurf;", + "8981": "telrec;", + "8982": "target;", + "8988": "ulcorner;", + "8989": "urcorner;", + "8990": "llcorner;", + "8991": "lrcorner;", + "8994": "sfrown;", + "8995": "ssmile;", + "9005": "cylcty;", + "9006": "profalar;", + "9014": "topbot;", + "9021": "ovbar;", + "9023": "solbar;", + "9084": "angzarr;", + "9136": "lmoustache;", + "9137": "rmoustache;", + "9140": "tbrk;", + "9141": "UnderBracket;", + "9142": "bbrktbrk;", + "9180": "OverParenthesis;", + "9181": "UnderParenthesis;", + "9182": "OverBrace;", + "9183": "UnderBrace;", + "9186": "trpezium;", + "9191": "elinters;", + "9251": "blank;", + "9416": "oS;", + "9472": "HorizontalLine;", + "9474": "boxv;", + "9484": "boxdr;", + "9488": "boxdl;", + "9492": "boxur;", + "9496": "boxul;", + "9500": "boxvr;", + "9508": "boxvl;", + "9516": "boxhd;", + "9524": "boxhu;", + "9532": "boxvh;", + "9552": "boxH;", + "9553": "boxV;", + "9554": "boxdR;", + "9555": "boxDr;", + "9556": "boxDR;", + "9557": "boxdL;", + "9558": "boxDl;", + "9559": "boxDL;", + "9560": "boxuR;", + "9561": "boxUr;", + "9562": "boxUR;", + "9563": "boxuL;", + "9564": "boxUl;", + "9565": "boxUL;", + "9566": "boxvR;", + "9567": "boxVr;", + "9568": "boxVR;", + "9569": "boxvL;", + "9570": "boxVl;", + "9571": "boxVL;", + "9572": "boxHd;", + "9573": "boxhD;", + "9574": "boxHD;", + "9575": "boxHu;", + "9576": "boxhU;", + "9577": "boxHU;", + "9578": "boxvH;", + "9579": "boxVh;", + "9580": "boxVH;", + "9600": "uhblk;", + "9604": "lhblk;", + "9608": "block;", + "9617": "blk14;", + "9618": "blk12;", + "9619": "blk34;", + "9633": "square;", + "9642": "squf;", + "9643": "EmptyVerySmallSquare;", + "9645": "rect;", + "9646": "marker;", + "9649": "fltns;", + "9651": "xutri;", + "9652": "utrif;", + "9653": "utri;", + "9656": "rtrif;", + "9657": "triangleright;", + "9661": "xdtri;", + "9662": "dtrif;", + "9663": "triangledown;", + "9666": "ltrif;", + "9667": "triangleleft;", + "9674": "lozenge;", + "9675": "cir;", + "9708": "tridot;", + "9711": "xcirc;", + "9720": "ultri;", + "9721": "urtri;", + "9722": "lltri;", + "9723": "EmptySmallSquare;", + "9724": "FilledSmallSquare;", + "9733": "starf;", + "9734": "star;", + "9742": "phone;", + "9792": "female;", + "9794": "male;", + "9824": "spadesuit;", + "9827": "clubsuit;", + "9829": "heartsuit;", + "9830": "diams;", + "9834": "sung;", + "9837": "flat;", + "9838": "natural;", + "9839": "sharp;", + "10003": "checkmark;", + "10007": "cross;", + "10016": "maltese;", + "10038": "sext;", + "10072": "VerticalSeparator;", + "10098": "lbbrk;", + "10099": "rbbrk;", + "10184": "bsolhsub;", + "10185": "suphsol;", + "10214": "lobrk;", + "10215": "robrk;", + "10216": "LeftAngleBracket;", + "10217": "RightAngleBracket;", + "10218": "Lang;", + "10219": "Rang;", + "10220": "loang;", + "10221": "roang;", + "10229": "xlarr;", + "10230": "xrarr;", + "10231": "xharr;", + "10232": "xlArr;", + "10233": "xrArr;", + "10234": "xhArr;", + "10236": "xmap;", + "10239": "dzigrarr;", + "10498": "nvlArr;", + "10499": "nvrArr;", + "10500": "nvHarr;", + "10501": "Map;", + "10508": "lbarr;", + "10509": "rbarr;", + "10510": "lBarr;", + "10511": "rBarr;", + "10512": "RBarr;", + "10513": "DDotrahd;", + "10514": "UpArrowBar;", + "10515": "DownArrowBar;", + "10518": "Rarrtl;", + "10521": "latail;", + "10522": "ratail;", + "10523": "lAtail;", + "10524": "rAtail;", + "10525": "larrfs;", + "10526": "rarrfs;", + "10527": "larrbfs;", + "10528": "rarrbfs;", + "10531": "nwarhk;", + "10532": "nearhk;", + "10533": "searhk;", + "10534": "swarhk;", + "10535": "nwnear;", + "10536": "toea;", + "10537": "tosa;", + "10538": "swnwar;", + "10547": "rarrc;", + "10549": "cudarrr;", + "10550": "ldca;", + "10551": "rdca;", + "10552": "cudarrl;", + "10553": "larrpl;", + "10556": "curarrm;", + "10557": "cularrp;", + "10565": "rarrpl;", + "10568": "harrcir;", + "10569": "Uarrocir;", + "10570": "lurdshar;", + "10571": "ldrushar;", + "10574": "LeftRightVector;", + "10575": "RightUpDownVector;", + "10576": "DownLeftRightVector;", + "10577": "LeftUpDownVector;", + "10578": "LeftVectorBar;", + "10579": "RightVectorBar;", + "10580": "RightUpVectorBar;", + "10581": "RightDownVectorBar;", + "10582": "DownLeftVectorBar;", + "10583": "DownRightVectorBar;", + "10584": "LeftUpVectorBar;", + "10585": "LeftDownVectorBar;", + "10586": "LeftTeeVector;", + "10587": "RightTeeVector;", + "10588": "RightUpTeeVector;", + "10589": "RightDownTeeVector;", + "10590": "DownLeftTeeVector;", + "10591": "DownRightTeeVector;", + "10592": "LeftUpTeeVector;", + "10593": "LeftDownTeeVector;", + "10594": "lHar;", + "10595": "uHar;", + "10596": "rHar;", + "10597": "dHar;", + "10598": "luruhar;", + "10599": "ldrdhar;", + "10600": "ruluhar;", + "10601": "rdldhar;", + "10602": "lharul;", + "10603": "llhard;", + "10604": "rharul;", + "10605": "lrhard;", + "10606": "UpEquilibrium;", + "10607": "ReverseUpEquilibrium;", + "10608": "RoundImplies;", + "10609": "erarr;", + "10610": "simrarr;", + "10611": "larrsim;", + "10612": "rarrsim;", + "10613": "rarrap;", + "10614": "ltlarr;", + "10616": "gtrarr;", + "10617": "subrarr;", + "10619": "suplarr;", + "10620": "lfisht;", + "10621": "rfisht;", + "10622": "ufisht;", + "10623": "dfisht;", + "10629": "lopar;", + "10630": "ropar;", + "10635": "lbrke;", + "10636": "rbrke;", + "10637": "lbrkslu;", + "10638": "rbrksld;", + "10639": "lbrksld;", + "10640": "rbrkslu;", + "10641": "langd;", + "10642": "rangd;", + "10643": "lparlt;", + "10644": "rpargt;", + "10645": "gtlPar;", + "10646": "ltrPar;", + "10650": "vzigzag;", + "10652": "vangrt;", + "10653": "angrtvbd;", + "10660": "ange;", + "10661": "range;", + "10662": "dwangle;", + "10663": "uwangle;", + "10664": "angmsdaa;", + "10665": "angmsdab;", + "10666": "angmsdac;", + "10667": "angmsdad;", + "10668": "angmsdae;", + "10669": "angmsdaf;", + "10670": "angmsdag;", + "10671": "angmsdah;", + "10672": "bemptyv;", + "10673": "demptyv;", + "10674": "cemptyv;", + "10675": "raemptyv;", + "10676": "laemptyv;", + "10677": "ohbar;", + "10678": "omid;", + "10679": "opar;", + "10681": "operp;", + "10683": "olcross;", + "10684": "odsold;", + "10686": "olcir;", + "10687": "ofcir;", + "10688": "olt;", + "10689": "ogt;", + "10690": "cirscir;", + "10691": "cirE;", + "10692": "solb;", + "10693": "bsolb;", + "10697": "boxbox;", + "10701": "trisb;", + "10702": "rtriltri;", + "10703": "LeftTriangleBar;", + "10704": "RightTriangleBar;", + "10716": "iinfin;", + "10717": "infintie;", + "10718": "nvinfin;", + "10723": "eparsl;", + "10724": "smeparsl;", + "10725": "eqvparsl;", + "10731": "lozf;", + "10740": "RuleDelayed;", + "10742": "dsol;", + "10752": "xodot;", + "10753": "xoplus;", + "10754": "xotime;", + "10756": "xuplus;", + "10758": "xsqcup;", + "10764": "qint;", + "10765": "fpartint;", + "10768": "cirfnint;", + "10769": "awint;", + "10770": "rppolint;", + "10771": "scpolint;", + "10772": "npolint;", + "10773": "pointint;", + "10774": "quatint;", + "10775": "intlarhk;", + "10786": "pluscir;", + "10787": "plusacir;", + "10788": "simplus;", + "10789": "plusdu;", + "10790": "plussim;", + "10791": "plustwo;", + "10793": "mcomma;", + "10794": "minusdu;", + "10797": "loplus;", + "10798": "roplus;", + "10799": "Cross;", + "10800": "timesd;", + "10801": "timesbar;", + "10803": "smashp;", + "10804": "lotimes;", + "10805": "rotimes;", + "10806": "otimesas;", + "10807": "Otimes;", + "10808": "odiv;", + "10809": "triplus;", + "10810": "triminus;", + "10811": "tritime;", + "10812": "iprod;", + "10815": "amalg;", + "10816": "capdot;", + "10818": "ncup;", + "10819": "ncap;", + "10820": "capand;", + "10821": "cupor;", + "10822": "cupcap;", + "10823": "capcup;", + "10824": "cupbrcap;", + "10825": "capbrcup;", + "10826": "cupcup;", + "10827": "capcap;", + "10828": "ccups;", + "10829": "ccaps;", + "10832": "ccupssm;", + "10835": "And;", + "10836": "Or;", + "10837": "andand;", + "10838": "oror;", + "10839": "orslope;", + "10840": "andslope;", + "10842": "andv;", + "10843": "orv;", + "10844": "andd;", + "10845": "ord;", + "10847": "wedbar;", + "10854": "sdote;", + "10858": "simdot;", + "10861": "congdot;", + "10862": "easter;", + "10863": "apacir;", + "10864": "apE;", + "10865": "eplus;", + "10866": "pluse;", + "10867": "Esim;", + "10868": "Colone;", + "10869": "Equal;", + "10871": "eDDot;", + "10872": "equivDD;", + "10873": "ltcir;", + "10874": "gtcir;", + "10875": "ltquest;", + "10876": "gtquest;", + "10877": "LessSlantEqual;", + "10878": "GreaterSlantEqual;", + "10879": "lesdot;", + "10880": "gesdot;", + "10881": "lesdoto;", + "10882": "gesdoto;", + "10883": "lesdotor;", + "10884": "gesdotol;", + "10885": "lessapprox;", + "10886": "gtrapprox;", + "10887": "lneq;", + "10888": "gneq;", + "10889": "lnapprox;", + "10890": "gnapprox;", + "10891": "lesseqqgtr;", + "10892": "gtreqqless;", + "10893": "lsime;", + "10894": "gsime;", + "10895": "lsimg;", + "10896": "gsiml;", + "10897": "lgE;", + "10898": "glE;", + "10899": "lesges;", + "10900": "gesles;", + "10901": "eqslantless;", + "10902": "eqslantgtr;", + "10903": "elsdot;", + "10904": "egsdot;", + "10905": "el;", + "10906": "eg;", + "10909": "siml;", + "10910": "simg;", + "10911": "simlE;", + "10912": "simgE;", + "10913": "LessLess;", + "10914": "GreaterGreater;", + "10916": "glj;", + "10917": "gla;", + "10918": "ltcc;", + "10919": "gtcc;", + "10920": "lescc;", + "10921": "gescc;", + "10922": "smt;", + "10923": "lat;", + "10924": "smte;", + "10925": "late;", + "10926": "bumpE;", + "10927": "preceq;", + "10928": "succeq;", + "10931": "prE;", + "10932": "scE;", + "10933": "prnE;", + "10934": "succneqq;", + "10935": "precapprox;", + "10936": "succapprox;", + "10937": "prnap;", + "10938": "succnapprox;", + "10939": "Pr;", + "10940": "Sc;", + "10941": "subdot;", + "10942": "supdot;", + "10943": "subplus;", + "10944": "supplus;", + "10945": "submult;", + "10946": "supmult;", + "10947": "subedot;", + "10948": "supedot;", + "10949": "subseteqq;", + "10950": "supseteqq;", + "10951": "subsim;", + "10952": "supsim;", + "10955": "subsetneqq;", + "10956": "supsetneqq;", + "10959": "csub;", + "10960": "csup;", + "10961": "csube;", + "10962": "csupe;", + "10963": "subsup;", + "10964": "supsub;", + "10965": "subsub;", + "10966": "supsup;", + "10967": "suphsub;", + "10968": "supdsub;", + "10969": "forkv;", + "10970": "topfork;", + "10971": "mlcp;", + "10980": "DoubleLeftTee;", + "10982": "Vdashl;", + "10983": "Barv;", + "10984": "vBar;", + "10985": "vBarv;", + "10987": "Vbar;", + "10988": "Not;", + "10989": "bNot;", + "10990": "rnmid;", + "10991": "cirmid;", + "10992": "midcir;", + "10993": "topcir;", + "10994": "nhpar;", + "10995": "parsim;", + "11005": "parsl;", + "64256": "fflig;", + "64257": "filig;", + "64258": "fllig;", + "64259": "ffilig;", + "64260": "ffllig;" +} +},{}],9:[function(require,module,exports){ +'use strict'; + +var hasOwn = Object.prototype.hasOwnProperty; +var toStr = Object.prototype.toString; +var defineProperty = Object.defineProperty; +var gOPD = Object.getOwnPropertyDescriptor; + +var isArray = function isArray(arr) { + if (typeof Array.isArray === 'function') { + return Array.isArray(arr); + } + + return toStr.call(arr) === '[object Array]'; +}; + +var isPlainObject = function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + + var hasOwnConstructor = hasOwn.call(obj, 'constructor'); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); + // Not own constructor property must be Object + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + + // Own properties are enumerated firstly, so to speed up, + // if last one is own, then all properties are own. + var key; + for (key in obj) { /**/ } + + return typeof key === 'undefined' || hasOwn.call(obj, key); +}; + +// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target +var setProperty = function setProperty(target, options) { + if (defineProperty && options.name === '__proto__') { + defineProperty(target, options.name, { + enumerable: true, + configurable: true, + value: options.newValue, + writable: true + }); + } else { + target[options.name] = options.newValue; + } +}; + +// Return undefined instead of __proto__ if '__proto__' is not an own property +var getProperty = function getProperty(obj, name) { + if (name === '__proto__') { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + // In early versions of node, obj['__proto__'] is buggy when obj has + // __proto__ as an own property. Object.getOwnPropertyDescriptor() works. + return gOPD(obj, name).value; + } + } + + return obj[name]; +}; + +module.exports = function extend() { + var options, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + + // Handle a deep copy situation + if (typeof target === 'boolean') { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { + target = {}; + } + + for (; i < length; ++i) { + options = arguments[i]; + // Only deal with non-null/undefined values + if (options != null) { + // Extend the base object + for (name in options) { + src = getProperty(target, name); + copy = getProperty(options, name); + + // Prevent never-ending loop + if (target !== copy) { + // Recurse if we're merging plain objects or arrays + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone them + setProperty(target, { name: name, newValue: extend(deep, clone, copy) }); + + // Don't bring in undefined values + } else if (typeof copy !== 'undefined') { + setProperty(target, { name: name, newValue: copy }); + } + } + } + } + } + + // Return the modified object + return target; +}; + +},{}],10:[function(require,module,exports){ +(function (global){ +/*! https://mths.be/punycode v1.4.1 by @mathias */ +;(function(root) { + + /** Detect free variables */ + var freeExports = typeof exports == 'object' && exports && + !exports.nodeType && exports; + var freeModule = typeof module == 'object' && module && + !module.nodeType && module; + var freeGlobal = typeof global == 'object' && global; + if ( + freeGlobal.global === freeGlobal || + freeGlobal.window === freeGlobal || + freeGlobal.self === freeGlobal + ) { + root = freeGlobal; + } + + /** + * The `punycode` object. + * @name punycode + * @type Object + */ + var punycode, + + /** Highest positive signed 32-bit float value */ + maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 + + /** Bootstring parameters */ + base = 36, + tMin = 1, + tMax = 26, + skew = 38, + damp = 700, + initialBias = 72, + initialN = 128, // 0x80 + delimiter = '-', // '\x2D' + + /** Regular expressions */ + regexPunycode = /^xn--/, + regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars + regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators + + /** Error messages */ + errors = { + 'overflow': 'Overflow: input needs wider integers to process', + 'not-basic': 'Illegal input >= 0x80 (not a basic code point)', + 'invalid-input': 'Invalid input' + }, + + /** Convenience shortcuts */ + baseMinusTMin = base - tMin, + floor = Math.floor, + stringFromCharCode = String.fromCharCode, + + /** Temporary variable */ + key; + + /*--------------------------------------------------------------------------*/ + + /** + * A generic error utility function. + * @private + * @param {String} type The error type. + * @returns {Error} Throws a `RangeError` with the applicable error message. + */ + function error(type) { + throw new RangeError(errors[type]); + } + + /** + * A generic `Array#map` utility function. + * @private + * @param {Array} array The array to iterate over. + * @param {Function} callback The function that gets called for every array + * item. + * @returns {Array} A new array of values returned by the callback function. + */ + function map(array, fn) { + var length = array.length; + var result = []; + while (length--) { + result[length] = fn(array[length]); + } + return result; + } + + /** + * A simple `Array#map`-like wrapper to work with domain name strings or email + * addresses. + * @private + * @param {String} domain The domain name or email address. + * @param {Function} callback The function that gets called for every + * character. + * @returns {Array} A new string of characters returned by the callback + * function. + */ + function mapDomain(string, fn) { + var parts = string.split('@'); + var result = ''; + if (parts.length > 1) { + // In email addresses, only the domain name should be punycoded. Leave + // the local part (i.e. everything up to `@`) intact. + result = parts[0] + '@'; + string = parts[1]; + } + // Avoid `split(regex)` for IE8 compatibility. See #17. + string = string.replace(regexSeparators, '\x2E'); + var labels = string.split('.'); + var encoded = map(labels, fn).join('.'); + return result + encoded; + } + + /** + * Creates an array containing the numeric code points of each Unicode + * character in the string. While JavaScript uses UCS-2 internally, + * this function will convert a pair of surrogate halves (each of which + * UCS-2 exposes as separate characters) into a single code point, + * matching UTF-16. + * @see `punycode.ucs2.encode` + * @see + * @memberOf punycode.ucs2 + * @name decode + * @param {String} string The Unicode input string (UCS-2). + * @returns {Array} The new array of code points. + */ + function ucs2decode(string) { + var output = [], + counter = 0, + length = string.length, + value, + extra; + while (counter < length) { + value = string.charCodeAt(counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + // high surrogate, and there is a next character + extra = string.charCodeAt(counter++); + if ((extra & 0xFC00) == 0xDC00) { // low surrogate + output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + // unmatched surrogate; only append this code unit, in case the next + // code unit is the high surrogate of a surrogate pair + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; + } + + /** + * Creates a string based on an array of numeric code points. + * @see `punycode.ucs2.decode` + * @memberOf punycode.ucs2 + * @name encode + * @param {Array} codePoints The array of numeric code points. + * @returns {String} The new Unicode string (UCS-2). + */ + function ucs2encode(array) { + return map(array, function(value) { + var output = ''; + if (value > 0xFFFF) { + value -= 0x10000; + output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); + value = 0xDC00 | value & 0x3FF; + } + output += stringFromCharCode(value); + return output; + }).join(''); + } + + /** + * Converts a basic code point into a digit/integer. + * @see `digitToBasic()` + * @private + * @param {Number} codePoint The basic numeric code point value. + * @returns {Number} The numeric value of a basic code point (for use in + * representing integers) in the range `0` to `base - 1`, or `base` if + * the code point does not represent a value. + */ + function basicToDigit(codePoint) { + if (codePoint - 48 < 10) { + return codePoint - 22; + } + if (codePoint - 65 < 26) { + return codePoint - 65; + } + if (codePoint - 97 < 26) { + return codePoint - 97; + } + return base; + } + + /** + * Converts a digit/integer into a basic code point. + * @see `basicToDigit()` + * @private + * @param {Number} digit The numeric value of a basic code point. + * @returns {Number} The basic code point whose value (when used for + * representing integers) is `digit`, which needs to be in the range + * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is + * used; else, the lowercase form is used. The behavior is undefined + * if `flag` is non-zero and `digit` has no uppercase form. + */ + function digitToBasic(digit, flag) { + // 0..25 map to ASCII a..z or A..Z + // 26..35 map to ASCII 0..9 + return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); + } + + /** + * Bias adaptation function as per section 3.4 of RFC 3492. + * https://tools.ietf.org/html/rfc3492#section-3.4 + * @private + */ + function adapt(delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { + delta = floor(delta / baseMinusTMin); + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); + } + + /** + * Converts a Punycode string of ASCII-only symbols to a string of Unicode + * symbols. + * @memberOf punycode + * @param {String} input The Punycode string of ASCII-only symbols. + * @returns {String} The resulting string of Unicode symbols. + */ + function decode(input) { + // Don't use UCS-2 + var output = [], + inputLength = input.length, + out, + i = 0, + n = initialN, + bias = initialBias, + basic, + j, + index, + oldi, + w, + k, + digit, + t, + /** Cached calculation results */ + baseMinusT; + + // Handle the basic code points: let `basic` be the number of input code + // points before the last delimiter, or `0` if there is none, then copy + // the first basic code points to the output. + + basic = input.lastIndexOf(delimiter); + if (basic < 0) { + basic = 0; + } + + for (j = 0; j < basic; ++j) { + // if it's not a basic code point + if (input.charCodeAt(j) >= 0x80) { + error('not-basic'); + } + output.push(input.charCodeAt(j)); + } + + // Main decoding loop: start just after the last delimiter if any basic code + // points were copied; start at the beginning otherwise. + + for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) { + + // `index` is the index of the next character to be consumed. + // Decode a generalized variable-length integer into `delta`, + // which gets added to `i`. The overflow checking is easier + // if we increase `i` as we go, then subtract off its starting + // value at the end to obtain `delta`. + for (oldi = i, w = 1, k = base; /* no condition */; k += base) { + + if (index >= inputLength) { + error('invalid-input'); + } + + digit = basicToDigit(input.charCodeAt(index++)); + + if (digit >= base || digit > floor((maxInt - i) / w)) { + error('overflow'); + } + + i += digit * w; + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + + if (digit < t) { + break; + } + + baseMinusT = base - t; + if (w > floor(maxInt / baseMinusT)) { + error('overflow'); + } + + w *= baseMinusT; + + } + + out = output.length + 1; + bias = adapt(i - oldi, out, oldi == 0); + + // `i` was supposed to wrap around from `out` to `0`, + // incrementing `n` each time, so we'll fix that now: + if (floor(i / out) > maxInt - n) { + error('overflow'); + } + + n += floor(i / out); + i %= out; + + // Insert `n` at position `i` of the output + output.splice(i++, 0, n); + + } + + return ucs2encode(output); + } + + /** + * Converts a string of Unicode symbols (e.g. a domain name label) to a + * Punycode string of ASCII-only symbols. + * @memberOf punycode + * @param {String} input The string of Unicode symbols. + * @returns {String} The resulting Punycode string of ASCII-only symbols. + */ + function encode(input) { + var n, + delta, + handledCPCount, + basicLength, + bias, + j, + m, + q, + k, + t, + currentValue, + output = [], + /** `inputLength` will hold the number of code points in `input`. */ + inputLength, + /** Cached calculation results */ + handledCPCountPlusOne, + baseMinusT, + qMinusT; + + // Convert the input in UCS-2 to Unicode + input = ucs2decode(input); + + // Cache the length + inputLength = input.length; + + // Initialize the state + n = initialN; + delta = 0; + bias = initialBias; + + // Handle the basic code points + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue < 0x80) { + output.push(stringFromCharCode(currentValue)); + } + } + + handledCPCount = basicLength = output.length; + + // `handledCPCount` is the number of code points that have been handled; + // `basicLength` is the number of basic code points. + + // Finish the basic string - if it is not empty - with a delimiter + if (basicLength) { + output.push(delimiter); + } + + // Main encoding loop: + while (handledCPCount < inputLength) { + + // All non-basic code points < n have been handled already. Find the next + // larger one: + for (m = maxInt, j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + + // Increase `delta` enough to advance the decoder's state to , + // but guard against overflow + handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + error('overflow'); + } + + delta += (m - n) * handledCPCountPlusOne; + n = m; + + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + + if (currentValue < n && ++delta > maxInt) { + error('overflow'); + } + + if (currentValue == n) { + // Represent delta as a generalized variable-length integer + for (q = delta, k = base; /* no condition */; k += base) { + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + if (q < t) { + break; + } + qMinusT = q - t; + baseMinusT = base - t; + output.push( + stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) + ); + q = floor(qMinusT / baseMinusT); + } + + output.push(stringFromCharCode(digitToBasic(q, 0))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); + delta = 0; + ++handledCPCount; + } + } + + ++delta; + ++n; + + } + return output.join(''); + } + + /** + * Converts a Punycode string representing a domain name or an email address + * to Unicode. Only the Punycoded parts of the input will be converted, i.e. + * it doesn't matter if you call it on a string that has already been + * converted to Unicode. + * @memberOf punycode + * @param {String} input The Punycoded domain name or email address to + * convert to Unicode. + * @returns {String} The Unicode representation of the given Punycode + * string. + */ + function toUnicode(input) { + return mapDomain(input, function(string) { + return regexPunycode.test(string) + ? decode(string.slice(4).toLowerCase()) + : string; + }); + } + + /** + * Converts a Unicode string representing a domain name or an email address to + * Punycode. Only the non-ASCII parts of the domain name will be converted, + * i.e. it doesn't matter if you call it with a domain that's already in + * ASCII. + * @memberOf punycode + * @param {String} input The domain name or email address to convert, as a + * Unicode string. + * @returns {String} The Punycode representation of the given domain name or + * email address. + */ + function toASCII(input) { + return mapDomain(input, function(string) { + return regexNonASCII.test(string) + ? 'xn--' + encode(string) + : string; + }); + } + + /*--------------------------------------------------------------------------*/ + + /** Define the public API */ + punycode = { + /** + * A string representing the current Punycode.js version number. + * @memberOf punycode + * @type String + */ + 'version': '1.4.1', + /** + * An object of methods to convert from JavaScript's internal character + * representation (UCS-2) to Unicode code points, and back. + * @see + * @memberOf punycode + * @type Object + */ + 'ucs2': { + 'decode': ucs2decode, + 'encode': ucs2encode + }, + 'decode': decode, + 'encode': encode, + 'toASCII': toASCII, + 'toUnicode': toUnicode + }; + + /** Expose `punycode` */ + // Some AMD build optimizers, like r.js, check for specific condition patterns + // like the following: + if ( + typeof define == 'function' && + typeof define.amd == 'object' && + define.amd + ) { + define('punycode', function() { + return punycode; + }); + } else if (freeExports && freeModule) { + if (module.exports == freeExports) { + // in Node.js, io.js, or RingoJS v0.8.0+ + freeModule.exports = punycode; + } else { + // in Narwhal or RingoJS v0.7.0- + for (key in punycode) { + punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]); + } + } + } else { + // in Rhino or a web browser + root.punycode = punycode; + } + +}(this)); + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],11:[function(require,module,exports){ +/** + * This file automatically generated from `pre-publish.js`. + * Do not manually edit. + */ + +module.exports = { + "area": true, + "base": true, + "br": true, + "col": true, + "embed": true, + "hr": true, + "img": true, + "input": true, + "keygen": true, + "link": true, + "menuitem": true, + "meta": true, + "param": true, + "source": true, + "track": true, + "wbr": true +}; + +},{}]},{},[4]); diff --git a/static/karma.js b/static/karma.js new file mode 100644 index 000000000..7e49c7c31 --- /dev/null +++ b/static/karma.js @@ -0,0 +1,2858 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i') + var doc = parser.parseFromString(string, 'text/html') + var ele = doc.head.firstChild || doc.body.firstChild + // script elements created by DomParser are marked as unexecutable, + // create a new script element manually and copy necessary properties + // so it is executable + if (ele.tagName && ele.tagName.toLowerCase() === 'script') { + var tmp = ele + ele = document.createElement('script') + ele.src = policy.createScriptURL(tmp.src) + ele.crossOrigin = tmp.crossOrigin + } + ele.onload = function () { + loadScript(idx + 1) + } + document.body.appendChild(ele) + } else { + window.__karma__.loaded() + } + } + loadScript(0) + } + // run in iframe + } else { + iframe.src = policy.createURL(url) + } + } + + this.onbeforeunload = function () { + if (!reloadingContext) { + // TODO(vojta): show what test (with explanation about jasmine.UPDATE_INTERVAL) + self.error('Some of your tests did a full page reload!') + } + } + + this.log = function (type, args) { + var values = [] + + for (var i = 0; i < args.length; i++) { + values.push(this.stringify(args[i], 3)) + } + + this.info({ log: values.join(', '), type: type }) + } + + this.stringify = stringify + + function clearContext () { + reloadingContext = true + + navigateContextTo('about:blank') + } + + function getLocation (url, lineno, colno) { + var location = '' + + if (url !== undefined) { + location += url + } + + if (lineno !== undefined) { + location += ':' + lineno + } + + if (colno !== undefined) { + location += ':' + colno + } + + return location + } + + // error during js file loading (most likely syntax error) + // we are not going to execute at all. `window.onerror` callback. + this.error = function (messageOrEvent, source, lineno, colno, error) { + var message + if (typeof messageOrEvent === 'string') { + message = messageOrEvent + + var location = getLocation(source, lineno, colno) + if (location !== '') { + message += '\nat ' + location + } + if (error && error.stack) { + message += '\n\n' + error.stack + } + } else { + // create an object with the string representation of the message to + // ensure all its content is properly transferred to the console log + message = { message: messageOrEvent, str: messageOrEvent.toString() } + } + + socket.emit('karma_error', message) + this.complete() + return false + } + + this.result = function (originalResult) { + var convertedResult = {} + + // Convert all array-like objects to real arrays. + for (var propertyName in originalResult) { + if (Object.prototype.hasOwnProperty.call(originalResult, propertyName)) { + var propertyValue = originalResult[propertyName] + + if (Object.prototype.toString.call(propertyValue) === '[object Array]') { + convertedResult[propertyName] = Array.prototype.slice.call(propertyValue) + } else { + convertedResult[propertyName] = propertyValue + } + } + } + + if (!startEmitted) { + socket.emit('start', { total: null }) + startEmitted = true + } + + if (resultsBufferLimit === 1) { + return socket.emit('result', convertedResult) + } + + resultsBuffer.push(convertedResult) + + if (resultsBuffer.length === resultsBufferLimit) { + socket.emit('result', resultsBuffer) + resultsBuffer = [] + } + } + + this.complete = function (result) { + if (resultsBuffer.length) { + socket.emit('result', resultsBuffer) + resultsBuffer = [] + } + + if (self.config.clearContext) { + // give the browser some time to breath, there could be a page reload, but because a bunch of + // tests could run in the same event loop, we wouldn't notice. + setTimeout(function () { + clearContext() + }, 0) + } + + socket.emit('complete', result || {}, function () { + if (returnUrl) { + location.href = returnUrl + } + }) + } + + this.info = function (info) { + // TODO(vojta): introduce special API for this + if (!startEmitted && util.isDefined(info.total)) { + socket.emit('start', info) + startEmitted = true + } else { + socket.emit('info', info) + } + } + + socket.on('execute', function (cfg) { + // reset startEmitted and reload the iframe + startEmitted = false + self.config = cfg + // if not clearing context, reloadingContext always true to prevent beforeUnload error + reloadingContext = !self.config.clearContext + navigateContextTo(constant.CONTEXT_URL) + + if (self.config.clientDisplayNone) { + [].forEach.call(document.querySelectorAll('#banner, #browsers'), function (el) { + el.style.display = 'none' + }) + } + + // clear the console before run + // works only on FF (Safari, Chrome do not allow to clear console from js source) + if (window.console && window.console.clear) { + window.console.clear() + } + }) + socket.on('stop', function () { + this.complete() + }.bind(this)) + + // Report the browser name and Id. Note that this event can also fire if the connection has + // been temporarily lost, but the socket reconnected automatically. Read more in the docs: + // https://socket.io/docs/client-api/#Event-%E2%80%98connect%E2%80%99 + socket.on('connect', function () { + socket.io.engine.on('upgrade', function () { + resultsBufferLimit = 1 + // Flush any results which were buffered before the upgrade to WebSocket protocol. + if (resultsBuffer.length > 0) { + socket.emit('result', resultsBuffer) + resultsBuffer = [] + } + }) + var info = { + name: navigator.userAgent, + id: browserId, + isSocketReconnect: socketReconnect + } + if (displayName) { + info.displayName = displayName + } + socket.emit('register', info) + }) + + socket.on('reconnect', function () { + socketReconnect = true + }) +} + +module.exports = Karma + +},{"../common/stringify":5,"../common/util":6,"./constants":1}],3:[function(require,module,exports){ +/* global io */ +/* eslint-disable no-new */ + +var Karma = require('./karma') +var StatusUpdater = require('./updater') +var util = require('../common/util') +var constants = require('./constants') + +var KARMA_URL_ROOT = constants.KARMA_URL_ROOT +var KARMA_PROXY_PATH = constants.KARMA_PROXY_PATH +var BROWSER_SOCKET_TIMEOUT = constants.BROWSER_SOCKET_TIMEOUT + +// Connect to the server using socket.io http://socket.io +var socket = io(location.host, { + reconnectionDelay: 500, + reconnectionDelayMax: Infinity, + timeout: BROWSER_SOCKET_TIMEOUT, + path: KARMA_PROXY_PATH + KARMA_URL_ROOT.substr(1) + 'socket.io', + 'sync disconnect on unload': true +}) + +// instantiate the updater of the view +new StatusUpdater(socket, util.elm('title'), util.elm('banner'), util.elm('browsers')) +window.karma = new Karma(socket, util.elm('context'), window.open, + window.navigator, window.location, window.document) + +},{"../common/util":6,"./constants":1,"./karma":2,"./updater":4}],4:[function(require,module,exports){ +var VERSION = require('./constants').VERSION + +function StatusUpdater (socket, titleElement, bannerElement, browsersElement) { + function updateBrowsersInfo (browsers) { + if (!browsersElement) { + return + } + var status + + // clear browsersElement + while (browsersElement.firstChild) { + browsersElement.removeChild(browsersElement.firstChild) + } + + for (var i = 0; i < browsers.length; i++) { + status = browsers[i].isConnected ? 'idle' : 'executing' + var li = document.createElement('li') + li.setAttribute('class', status) + li.textContent = browsers[i].name + ' is ' + status + browsersElement.appendChild(li) + } + } + + function updateBanner (status) { + return function (param) { + if (!titleElement || !bannerElement) { + return + } + var paramStatus = param ? status.replace('$', param) : status + titleElement.textContent = 'Karma v' + VERSION + ' - ' + paramStatus + bannerElement.className = status === 'connected' ? 'online' : 'offline' + } + } + + socket.on('connect', updateBanner('connected')) + socket.on('disconnect', updateBanner('disconnected')) + socket.on('reconnecting', updateBanner('reconnecting in $ seconds...')) + socket.on('reconnect', updateBanner('connected')) + socket.on('reconnect_failed', updateBanner('failed to reconnect')) + socket.on('info', updateBrowsersInfo) + socket.on('disconnect', function () { + updateBrowsersInfo([]) + }) +} + +module.exports = StatusUpdater + +},{"./constants":1}],5:[function(require,module,exports){ +var serialize = null +try { + serialize = require('dom-serialize') +} catch (e) { + // Ignore failure on IE8 +} + +var instanceOf = require('./util').instanceOf + +function isNode (obj) { + return (obj.tagName || obj.nodeName) && obj.nodeType +} + +function stringify (obj, depth) { + if (depth === 0) { + return '...' + } + + if (obj === null) { + return 'null' + } + + switch (typeof obj) { + case 'symbol': + return obj.toString() + case 'string': + return "'" + obj + "'" + case 'undefined': + return 'undefined' + case 'function': + try { + // function abc(a, b, c) { /* code goes here */ } + // -> function abc(a, b, c) { ... } + return obj.toString().replace(/\{[\s\S]*\}/, '{ ... }') + } catch (err) { + if (err instanceof TypeError) { + // Support older browsers + return 'function ' + (obj.name || '') + '() { ... }' + } else { + throw err + } + } + case 'boolean': + return obj ? 'true' : 'false' + case 'object': + var strs = [] + if (instanceOf(obj, 'Array')) { + strs.push('[') + for (var i = 0, ii = obj.length; i < ii; i++) { + if (i) { + strs.push(', ') + } + strs.push(stringify(obj[i], depth - 1)) + } + strs.push(']') + } else if (instanceOf(obj, 'Date')) { + return obj.toString() + } else if (instanceOf(obj, 'Text')) { + return obj.nodeValue + } else if (instanceOf(obj, 'Comment')) { + return '' + } else if (obj.outerHTML) { + return obj.outerHTML + } else if (isNode(obj)) { + if (serialize) { + return serialize(obj) + } else { + return 'Skipping stringify, no support for dom-serialize' + } + } else if (instanceOf(obj, 'Error')) { + return obj.toString() + '\n' + obj.stack + } else { + var constructor = 'Object' + if (obj.constructor && typeof obj.constructor === 'function') { + constructor = obj.constructor.name + } + + strs.push(constructor) + strs.push('{') + var first = true + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + if (first) { + first = false + } else { + strs.push(', ') + } + + strs.push(key + ': ' + stringify(obj[key], depth - 1)) + } + } + strs.push('}') + } + return strs.join('') + default: + return obj + } +} + +module.exports = stringify + +},{"./util":6,"dom-serialize":8}],6:[function(require,module,exports){ +exports.instanceOf = function (value, constructorName) { + return Object.prototype.toString.apply(value) === '[object ' + constructorName + ']' +} + +exports.elm = function (id) { + return document.getElementById(id) +} + +exports.generateId = function (prefix) { + return prefix + Math.floor(Math.random() * 10000) +} + +exports.isUndefined = function (value) { + return typeof value === 'undefined' +} + +exports.isDefined = function (value) { + return !exports.isUndefined(value) +} + +exports.parseQueryParams = function (locationSearch) { + var params = {} + var pairs = locationSearch.substr(1).split('&') + var keyValue + + for (var i = 0; i < pairs.length; i++) { + keyValue = pairs[i].split('=') + params[decodeURIComponent(keyValue[0])] = decodeURIComponent(keyValue[1]) + } + + return params +} + +},{}],7:[function(require,module,exports){ +(function (global){ + +var NativeCustomEvent = global.CustomEvent; + +function useNative () { + try { + var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } }); + return 'cat' === p.type && 'bar' === p.detail.foo; + } catch (e) { + } + return false; +} + +/** + * Cross-browser `CustomEvent` constructor. + * + * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent + * + * @public + */ + +module.exports = useNative() ? NativeCustomEvent : + +// IE >= 9 +'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) { + var e = document.createEvent('CustomEvent'); + if (params) { + e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail); + } else { + e.initCustomEvent(type, false, false, void 0); + } + return e; +} : + +// IE <= 8 +function CustomEvent (type, params) { + var e = document.createEventObject(); + e.type = type; + if (params) { + e.bubbles = Boolean(params.bubbles); + e.cancelable = Boolean(params.cancelable); + e.detail = params.detail; + } else { + e.bubbles = false; + e.cancelable = false; + e.detail = void 0; + } + return e; +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],8:[function(require,module,exports){ + +/** + * Module dependencies. + */ + +var extend = require('extend'); +var encode = require('ent/encode'); +var CustomEvent = require('custom-event'); +var voidElements = require('void-elements'); + +/** + * Module exports. + */ + +exports = module.exports = serialize; +exports.serializeElement = serializeElement; +exports.serializeAttribute = serializeAttribute; +exports.serializeText = serializeText; +exports.serializeComment = serializeComment; +exports.serializeDocument = serializeDocument; +exports.serializeDoctype = serializeDoctype; +exports.serializeDocumentFragment = serializeDocumentFragment; +exports.serializeNodeList = serializeNodeList; + +/** + * Serializes any DOM node. Returns a string. + * + * @param {Node} node - DOM Node to serialize + * @param {String} [context] - optional arbitrary "context" string to use (useful for event listeners) + * @param {Function} [fn] - optional callback function to use in the "serialize" event for this call + * @param {EventTarget} [eventTarget] - optional EventTarget instance to emit the "serialize" event on (defaults to `node`) + * return {String} + * @public + */ + +function serialize (node, context, fn, eventTarget) { + if (!node) return ''; + if ('function' === typeof context) { + fn = context; + context = null; + } + if (!context) context = null; + + var rtn; + var nodeType = node.nodeType; + + if (!nodeType && 'number' === typeof node.length) { + // assume it's a NodeList or Array of Nodes + rtn = exports.serializeNodeList(node, context, fn); + } else { + + if ('function' === typeof fn) { + // one-time "serialize" event listener + node.addEventListener('serialize', fn, false); + } + + // emit a custom "serialize" event on `node`, in case there + // are event listeners for custom serialization of this node + var e = new CustomEvent('serialize', { + bubbles: true, + cancelable: true, + detail: { + serialize: null, + context: context + } + }); + + e.serializeTarget = node; + + var target = eventTarget || node; + var cancelled = !target.dispatchEvent(e); + + // `e.detail.serialize` can be set to a: + // String - returned directly + // Node - goes through serializer logic instead of `node` + // Anything else - get Stringified first, and then returned directly + var s = e.detail.serialize; + if (s != null) { + if ('string' === typeof s) { + rtn = s; + } else if ('number' === typeof s.nodeType) { + // make it go through the serialization logic + rtn = serialize(s, context, null, target); + } else { + rtn = String(s); + } + } else if (!cancelled) { + // default serialization logic + switch (nodeType) { + case 1 /* element */: + rtn = exports.serializeElement(node, context, eventTarget); + break; + case 2 /* attribute */: + rtn = exports.serializeAttribute(node); + break; + case 3 /* text */: + rtn = exports.serializeText(node); + break; + case 8 /* comment */: + rtn = exports.serializeComment(node); + break; + case 9 /* document */: + rtn = exports.serializeDocument(node, context, eventTarget); + break; + case 10 /* doctype */: + rtn = exports.serializeDoctype(node); + break; + case 11 /* document fragment */: + rtn = exports.serializeDocumentFragment(node, context, eventTarget); + break; + } + } + + if ('function' === typeof fn) { + node.removeEventListener('serialize', fn, false); + } + } + + return rtn || ''; +} + +/** + * Serialize an Attribute node. + */ + +function serializeAttribute (node, opts) { + return node.name + '="' + encode(node.value, extend({ + named: true + }, opts)) + '"'; +} + +/** + * Serialize a DOM element. + */ + +function serializeElement (node, context, eventTarget) { + var c, i, l; + var name = node.nodeName.toLowerCase(); + + // opening tag + var r = '<' + name; + + // attributes + for (i = 0, c = node.attributes, l = c.length; i < l; i++) { + r += ' ' + exports.serializeAttribute(c[i]); + } + + r += '>'; + + // child nodes + r += exports.serializeNodeList(node.childNodes, context, null, eventTarget); + + // closing tag, only for non-void elements + if (!voidElements[name]) { + r += ''; + } + + return r; +} + +/** + * Serialize a text node. + */ + +function serializeText (node, opts) { + return encode(node.nodeValue, extend({ + named: true, + special: { '<': true, '>': true, '&': true } + }, opts)); +} + +/** + * Serialize a comment node. + */ + +function serializeComment (node) { + return ''; +} + +/** + * Serialize a Document node. + */ + +function serializeDocument (node, context, eventTarget) { + return exports.serializeNodeList(node.childNodes, context, null, eventTarget); +} + +/** + * Serialize a DOCTYPE node. + * See: http://stackoverflow.com/a/10162353 + */ + +function serializeDoctype (node) { + var r = ''; + return r; +} + +/** + * Serialize a DocumentFragment instance. + */ + +function serializeDocumentFragment (node, context, eventTarget) { + return exports.serializeNodeList(node.childNodes, context, null, eventTarget); +} + +/** + * Serialize a NodeList/Array of nodes. + */ + +function serializeNodeList (list, context, fn, eventTarget) { + var r = ''; + for (var i = 0, l = list.length; i < l; i++) { + r += serialize(list[i], context, fn, eventTarget); + } + return r; +} + +},{"custom-event":7,"ent/encode":9,"extend":11,"void-elements":13}],9:[function(require,module,exports){ +var punycode = require('punycode'); +var revEntities = require('./reversed.json'); + +module.exports = encode; + +function encode (str, opts) { + if (typeof str !== 'string') { + throw new TypeError('Expected a String'); + } + if (!opts) opts = {}; + + var numeric = true; + if (opts.named) numeric = false; + if (opts.numeric !== undefined) numeric = opts.numeric; + + var special = opts.special || { + '"': true, "'": true, + '<': true, '>': true, + '&': true + }; + + var codePoints = punycode.ucs2.decode(str); + var chars = []; + for (var i = 0; i < codePoints.length; i++) { + var cc = codePoints[i]; + var c = punycode.ucs2.encode([ cc ]); + var e = revEntities[cc]; + if (e && (cc >= 127 || special[c]) && !numeric) { + chars.push('&' + (/;$/.test(e) ? e : e + ';')); + } + else if (cc < 32 || cc >= 127 || special[c]) { + chars.push('&#' + cc + ';'); + } + else { + chars.push(c); + } + } + return chars.join(''); +} + +},{"./reversed.json":10,"punycode":12}],10:[function(require,module,exports){ +module.exports={ + "9": "Tab;", + "10": "NewLine;", + "33": "excl;", + "34": "quot;", + "35": "num;", + "36": "dollar;", + "37": "percnt;", + "38": "amp;", + "39": "apos;", + "40": "lpar;", + "41": "rpar;", + "42": "midast;", + "43": "plus;", + "44": "comma;", + "46": "period;", + "47": "sol;", + "58": "colon;", + "59": "semi;", + "60": "lt;", + "61": "equals;", + "62": "gt;", + "63": "quest;", + "64": "commat;", + "91": "lsqb;", + "92": "bsol;", + "93": "rsqb;", + "94": "Hat;", + "95": "UnderBar;", + "96": "grave;", + "123": "lcub;", + "124": "VerticalLine;", + "125": "rcub;", + "160": "NonBreakingSpace;", + "161": "iexcl;", + "162": "cent;", + "163": "pound;", + "164": "curren;", + "165": "yen;", + "166": "brvbar;", + "167": "sect;", + "168": "uml;", + "169": "copy;", + "170": "ordf;", + "171": "laquo;", + "172": "not;", + "173": "shy;", + "174": "reg;", + "175": "strns;", + "176": "deg;", + "177": "pm;", + "178": "sup2;", + "179": "sup3;", + "180": "DiacriticalAcute;", + "181": "micro;", + "182": "para;", + "183": "middot;", + "184": "Cedilla;", + "185": "sup1;", + "186": "ordm;", + "187": "raquo;", + "188": "frac14;", + "189": "half;", + "190": "frac34;", + "191": "iquest;", + "192": "Agrave;", + "193": "Aacute;", + "194": "Acirc;", + "195": "Atilde;", + "196": "Auml;", + "197": "Aring;", + "198": "AElig;", + "199": "Ccedil;", + "200": "Egrave;", + "201": "Eacute;", + "202": "Ecirc;", + "203": "Euml;", + "204": "Igrave;", + "205": "Iacute;", + "206": "Icirc;", + "207": "Iuml;", + "208": "ETH;", + "209": "Ntilde;", + "210": "Ograve;", + "211": "Oacute;", + "212": "Ocirc;", + "213": "Otilde;", + "214": "Ouml;", + "215": "times;", + "216": "Oslash;", + "217": "Ugrave;", + "218": "Uacute;", + "219": "Ucirc;", + "220": "Uuml;", + "221": "Yacute;", + "222": "THORN;", + "223": "szlig;", + "224": "agrave;", + "225": "aacute;", + "226": "acirc;", + "227": "atilde;", + "228": "auml;", + "229": "aring;", + "230": "aelig;", + "231": "ccedil;", + "232": "egrave;", + "233": "eacute;", + "234": "ecirc;", + "235": "euml;", + "236": "igrave;", + "237": "iacute;", + "238": "icirc;", + "239": "iuml;", + "240": "eth;", + "241": "ntilde;", + "242": "ograve;", + "243": "oacute;", + "244": "ocirc;", + "245": "otilde;", + "246": "ouml;", + "247": "divide;", + "248": "oslash;", + "249": "ugrave;", + "250": "uacute;", + "251": "ucirc;", + "252": "uuml;", + "253": "yacute;", + "254": "thorn;", + "255": "yuml;", + "256": "Amacr;", + "257": "amacr;", + "258": "Abreve;", + "259": "abreve;", + "260": "Aogon;", + "261": "aogon;", + "262": "Cacute;", + "263": "cacute;", + "264": "Ccirc;", + "265": "ccirc;", + "266": "Cdot;", + "267": "cdot;", + "268": "Ccaron;", + "269": "ccaron;", + "270": "Dcaron;", + "271": "dcaron;", + "272": "Dstrok;", + "273": "dstrok;", + "274": "Emacr;", + "275": "emacr;", + "278": "Edot;", + "279": "edot;", + "280": "Eogon;", + "281": "eogon;", + "282": "Ecaron;", + "283": "ecaron;", + "284": "Gcirc;", + "285": "gcirc;", + "286": "Gbreve;", + "287": "gbreve;", + "288": "Gdot;", + "289": "gdot;", + "290": "Gcedil;", + "292": "Hcirc;", + "293": "hcirc;", + "294": "Hstrok;", + "295": "hstrok;", + "296": "Itilde;", + "297": "itilde;", + "298": "Imacr;", + "299": "imacr;", + "302": "Iogon;", + "303": "iogon;", + "304": "Idot;", + "305": "inodot;", + "306": "IJlig;", + "307": "ijlig;", + "308": "Jcirc;", + "309": "jcirc;", + "310": "Kcedil;", + "311": "kcedil;", + "312": "kgreen;", + "313": "Lacute;", + "314": "lacute;", + "315": "Lcedil;", + "316": "lcedil;", + "317": "Lcaron;", + "318": "lcaron;", + "319": "Lmidot;", + "320": "lmidot;", + "321": "Lstrok;", + "322": "lstrok;", + "323": "Nacute;", + "324": "nacute;", + "325": "Ncedil;", + "326": "ncedil;", + "327": "Ncaron;", + "328": "ncaron;", + "329": "napos;", + "330": "ENG;", + "331": "eng;", + "332": "Omacr;", + "333": "omacr;", + "336": "Odblac;", + "337": "odblac;", + "338": "OElig;", + "339": "oelig;", + "340": "Racute;", + "341": "racute;", + "342": "Rcedil;", + "343": "rcedil;", + "344": "Rcaron;", + "345": "rcaron;", + "346": "Sacute;", + "347": "sacute;", + "348": "Scirc;", + "349": "scirc;", + "350": "Scedil;", + "351": "scedil;", + "352": "Scaron;", + "353": "scaron;", + "354": "Tcedil;", + "355": "tcedil;", + "356": "Tcaron;", + "357": "tcaron;", + "358": "Tstrok;", + "359": "tstrok;", + "360": "Utilde;", + "361": "utilde;", + "362": "Umacr;", + "363": "umacr;", + "364": "Ubreve;", + "365": "ubreve;", + "366": "Uring;", + "367": "uring;", + "368": "Udblac;", + "369": "udblac;", + "370": "Uogon;", + "371": "uogon;", + "372": "Wcirc;", + "373": "wcirc;", + "374": "Ycirc;", + "375": "ycirc;", + "376": "Yuml;", + "377": "Zacute;", + "378": "zacute;", + "379": "Zdot;", + "380": "zdot;", + "381": "Zcaron;", + "382": "zcaron;", + "402": "fnof;", + "437": "imped;", + "501": "gacute;", + "567": "jmath;", + "710": "circ;", + "711": "Hacek;", + "728": "breve;", + "729": "dot;", + "730": "ring;", + "731": "ogon;", + "732": "tilde;", + "733": "DiacriticalDoubleAcute;", + "785": "DownBreve;", + "913": "Alpha;", + "914": "Beta;", + "915": "Gamma;", + "916": "Delta;", + "917": "Epsilon;", + "918": "Zeta;", + "919": "Eta;", + "920": "Theta;", + "921": "Iota;", + "922": "Kappa;", + "923": "Lambda;", + "924": "Mu;", + "925": "Nu;", + "926": "Xi;", + "927": "Omicron;", + "928": "Pi;", + "929": "Rho;", + "931": "Sigma;", + "932": "Tau;", + "933": "Upsilon;", + "934": "Phi;", + "935": "Chi;", + "936": "Psi;", + "937": "Omega;", + "945": "alpha;", + "946": "beta;", + "947": "gamma;", + "948": "delta;", + "949": "epsilon;", + "950": "zeta;", + "951": "eta;", + "952": "theta;", + "953": "iota;", + "954": "kappa;", + "955": "lambda;", + "956": "mu;", + "957": "nu;", + "958": "xi;", + "959": "omicron;", + "960": "pi;", + "961": "rho;", + "962": "varsigma;", + "963": "sigma;", + "964": "tau;", + "965": "upsilon;", + "966": "phi;", + "967": "chi;", + "968": "psi;", + "969": "omega;", + "977": "vartheta;", + "978": "upsih;", + "981": "varphi;", + "982": "varpi;", + "988": "Gammad;", + "989": "gammad;", + "1008": "varkappa;", + "1009": "varrho;", + "1013": "varepsilon;", + "1014": "bepsi;", + "1025": "IOcy;", + "1026": "DJcy;", + "1027": "GJcy;", + "1028": "Jukcy;", + "1029": "DScy;", + "1030": "Iukcy;", + "1031": "YIcy;", + "1032": "Jsercy;", + "1033": "LJcy;", + "1034": "NJcy;", + "1035": "TSHcy;", + "1036": "KJcy;", + "1038": "Ubrcy;", + "1039": "DZcy;", + "1040": "Acy;", + "1041": "Bcy;", + "1042": "Vcy;", + "1043": "Gcy;", + "1044": "Dcy;", + "1045": "IEcy;", + "1046": "ZHcy;", + "1047": "Zcy;", + "1048": "Icy;", + "1049": "Jcy;", + "1050": "Kcy;", + "1051": "Lcy;", + "1052": "Mcy;", + "1053": "Ncy;", + "1054": "Ocy;", + "1055": "Pcy;", + "1056": "Rcy;", + "1057": "Scy;", + "1058": "Tcy;", + "1059": "Ucy;", + "1060": "Fcy;", + "1061": "KHcy;", + "1062": "TScy;", + "1063": "CHcy;", + "1064": "SHcy;", + "1065": "SHCHcy;", + "1066": "HARDcy;", + "1067": "Ycy;", + "1068": "SOFTcy;", + "1069": "Ecy;", + "1070": "YUcy;", + "1071": "YAcy;", + "1072": "acy;", + "1073": "bcy;", + "1074": "vcy;", + "1075": "gcy;", + "1076": "dcy;", + "1077": "iecy;", + "1078": "zhcy;", + "1079": "zcy;", + "1080": "icy;", + "1081": "jcy;", + "1082": "kcy;", + "1083": "lcy;", + "1084": "mcy;", + "1085": "ncy;", + "1086": "ocy;", + "1087": "pcy;", + "1088": "rcy;", + "1089": "scy;", + "1090": "tcy;", + "1091": "ucy;", + "1092": "fcy;", + "1093": "khcy;", + "1094": "tscy;", + "1095": "chcy;", + "1096": "shcy;", + "1097": "shchcy;", + "1098": "hardcy;", + "1099": "ycy;", + "1100": "softcy;", + "1101": "ecy;", + "1102": "yucy;", + "1103": "yacy;", + "1105": "iocy;", + "1106": "djcy;", + "1107": "gjcy;", + "1108": "jukcy;", + "1109": "dscy;", + "1110": "iukcy;", + "1111": "yicy;", + "1112": "jsercy;", + "1113": "ljcy;", + "1114": "njcy;", + "1115": "tshcy;", + "1116": "kjcy;", + "1118": "ubrcy;", + "1119": "dzcy;", + "8194": "ensp;", + "8195": "emsp;", + "8196": "emsp13;", + "8197": "emsp14;", + "8199": "numsp;", + "8200": "puncsp;", + "8201": "ThinSpace;", + "8202": "VeryThinSpace;", + "8203": "ZeroWidthSpace;", + "8204": "zwnj;", + "8205": "zwj;", + "8206": "lrm;", + "8207": "rlm;", + "8208": "hyphen;", + "8211": "ndash;", + "8212": "mdash;", + "8213": "horbar;", + "8214": "Vert;", + "8216": "OpenCurlyQuote;", + "8217": "rsquor;", + "8218": "sbquo;", + "8220": "OpenCurlyDoubleQuote;", + "8221": "rdquor;", + "8222": "ldquor;", + "8224": "dagger;", + "8225": "ddagger;", + "8226": "bullet;", + "8229": "nldr;", + "8230": "mldr;", + "8240": "permil;", + "8241": "pertenk;", + "8242": "prime;", + "8243": "Prime;", + "8244": "tprime;", + "8245": "bprime;", + "8249": "lsaquo;", + "8250": "rsaquo;", + "8254": "OverBar;", + "8257": "caret;", + "8259": "hybull;", + "8260": "frasl;", + "8271": "bsemi;", + "8279": "qprime;", + "8287": "MediumSpace;", + "8288": "NoBreak;", + "8289": "ApplyFunction;", + "8290": "it;", + "8291": "InvisibleComma;", + "8364": "euro;", + "8411": "TripleDot;", + "8412": "DotDot;", + "8450": "Copf;", + "8453": "incare;", + "8458": "gscr;", + "8459": "Hscr;", + "8460": "Poincareplane;", + "8461": "quaternions;", + "8462": "planckh;", + "8463": "plankv;", + "8464": "Iscr;", + "8465": "imagpart;", + "8466": "Lscr;", + "8467": "ell;", + "8469": "Nopf;", + "8470": "numero;", + "8471": "copysr;", + "8472": "wp;", + "8473": "primes;", + "8474": "rationals;", + "8475": "Rscr;", + "8476": "Rfr;", + "8477": "Ropf;", + "8478": "rx;", + "8482": "trade;", + "8484": "Zopf;", + "8487": "mho;", + "8488": "Zfr;", + "8489": "iiota;", + "8492": "Bscr;", + "8493": "Cfr;", + "8495": "escr;", + "8496": "expectation;", + "8497": "Fscr;", + "8499": "phmmat;", + "8500": "oscr;", + "8501": "aleph;", + "8502": "beth;", + "8503": "gimel;", + "8504": "daleth;", + "8517": "DD;", + "8518": "DifferentialD;", + "8519": "exponentiale;", + "8520": "ImaginaryI;", + "8531": "frac13;", + "8532": "frac23;", + "8533": "frac15;", + "8534": "frac25;", + "8535": "frac35;", + "8536": "frac45;", + "8537": "frac16;", + "8538": "frac56;", + "8539": "frac18;", + "8540": "frac38;", + "8541": "frac58;", + "8542": "frac78;", + "8592": "slarr;", + "8593": "uparrow;", + "8594": "srarr;", + "8595": "ShortDownArrow;", + "8596": "leftrightarrow;", + "8597": "varr;", + "8598": "UpperLeftArrow;", + "8599": "UpperRightArrow;", + "8600": "searrow;", + "8601": "swarrow;", + "8602": "nleftarrow;", + "8603": "nrightarrow;", + "8605": "rightsquigarrow;", + "8606": "twoheadleftarrow;", + "8607": "Uarr;", + "8608": "twoheadrightarrow;", + "8609": "Darr;", + "8610": "leftarrowtail;", + "8611": "rightarrowtail;", + "8612": "mapstoleft;", + "8613": "UpTeeArrow;", + "8614": "RightTeeArrow;", + "8615": "mapstodown;", + "8617": "larrhk;", + "8618": "rarrhk;", + "8619": "looparrowleft;", + "8620": "rarrlp;", + "8621": "leftrightsquigarrow;", + "8622": "nleftrightarrow;", + "8624": "lsh;", + "8625": "rsh;", + "8626": "ldsh;", + "8627": "rdsh;", + "8629": "crarr;", + "8630": "curvearrowleft;", + "8631": "curvearrowright;", + "8634": "olarr;", + "8635": "orarr;", + "8636": "lharu;", + "8637": "lhard;", + "8638": "upharpoonright;", + "8639": "upharpoonleft;", + "8640": "RightVector;", + "8641": "rightharpoondown;", + "8642": "RightDownVector;", + "8643": "LeftDownVector;", + "8644": "rlarr;", + "8645": "UpArrowDownArrow;", + "8646": "lrarr;", + "8647": "llarr;", + "8648": "uuarr;", + "8649": "rrarr;", + "8650": "downdownarrows;", + "8651": "ReverseEquilibrium;", + "8652": "rlhar;", + "8653": "nLeftarrow;", + "8654": "nLeftrightarrow;", + "8655": "nRightarrow;", + "8656": "Leftarrow;", + "8657": "Uparrow;", + "8658": "Rightarrow;", + "8659": "Downarrow;", + "8660": "Leftrightarrow;", + "8661": "vArr;", + "8662": "nwArr;", + "8663": "neArr;", + "8664": "seArr;", + "8665": "swArr;", + "8666": "Lleftarrow;", + "8667": "Rrightarrow;", + "8669": "zigrarr;", + "8676": "LeftArrowBar;", + "8677": "RightArrowBar;", + "8693": "duarr;", + "8701": "loarr;", + "8702": "roarr;", + "8703": "hoarr;", + "8704": "forall;", + "8705": "complement;", + "8706": "PartialD;", + "8707": "Exists;", + "8708": "NotExists;", + "8709": "varnothing;", + "8711": "nabla;", + "8712": "isinv;", + "8713": "notinva;", + "8715": "SuchThat;", + "8716": "NotReverseElement;", + "8719": "Product;", + "8720": "Coproduct;", + "8721": "sum;", + "8722": "minus;", + "8723": "mp;", + "8724": "plusdo;", + "8726": "ssetmn;", + "8727": "lowast;", + "8728": "SmallCircle;", + "8730": "Sqrt;", + "8733": "vprop;", + "8734": "infin;", + "8735": "angrt;", + "8736": "angle;", + "8737": "measuredangle;", + "8738": "angsph;", + "8739": "VerticalBar;", + "8740": "nsmid;", + "8741": "spar;", + "8742": "nspar;", + "8743": "wedge;", + "8744": "vee;", + "8745": "cap;", + "8746": "cup;", + "8747": "Integral;", + "8748": "Int;", + "8749": "tint;", + "8750": "oint;", + "8751": "DoubleContourIntegral;", + "8752": "Cconint;", + "8753": "cwint;", + "8754": "cwconint;", + "8755": "CounterClockwiseContourIntegral;", + "8756": "therefore;", + "8757": "because;", + "8758": "ratio;", + "8759": "Proportion;", + "8760": "minusd;", + "8762": "mDDot;", + "8763": "homtht;", + "8764": "Tilde;", + "8765": "bsim;", + "8766": "mstpos;", + "8767": "acd;", + "8768": "wreath;", + "8769": "nsim;", + "8770": "esim;", + "8771": "TildeEqual;", + "8772": "nsimeq;", + "8773": "TildeFullEqual;", + "8774": "simne;", + "8775": "NotTildeFullEqual;", + "8776": "TildeTilde;", + "8777": "NotTildeTilde;", + "8778": "approxeq;", + "8779": "apid;", + "8780": "bcong;", + "8781": "CupCap;", + "8782": "HumpDownHump;", + "8783": "HumpEqual;", + "8784": "esdot;", + "8785": "eDot;", + "8786": "fallingdotseq;", + "8787": "risingdotseq;", + "8788": "coloneq;", + "8789": "eqcolon;", + "8790": "eqcirc;", + "8791": "cire;", + "8793": "wedgeq;", + "8794": "veeeq;", + "8796": "trie;", + "8799": "questeq;", + "8800": "NotEqual;", + "8801": "equiv;", + "8802": "NotCongruent;", + "8804": "leq;", + "8805": "GreaterEqual;", + "8806": "LessFullEqual;", + "8807": "GreaterFullEqual;", + "8808": "lneqq;", + "8809": "gneqq;", + "8810": "NestedLessLess;", + "8811": "NestedGreaterGreater;", + "8812": "twixt;", + "8813": "NotCupCap;", + "8814": "NotLess;", + "8815": "NotGreater;", + "8816": "NotLessEqual;", + "8817": "NotGreaterEqual;", + "8818": "lsim;", + "8819": "gtrsim;", + "8820": "NotLessTilde;", + "8821": "NotGreaterTilde;", + "8822": "lg;", + "8823": "gtrless;", + "8824": "ntlg;", + "8825": "ntgl;", + "8826": "Precedes;", + "8827": "Succeeds;", + "8828": "PrecedesSlantEqual;", + "8829": "SucceedsSlantEqual;", + "8830": "prsim;", + "8831": "succsim;", + "8832": "nprec;", + "8833": "nsucc;", + "8834": "subset;", + "8835": "supset;", + "8836": "nsub;", + "8837": "nsup;", + "8838": "SubsetEqual;", + "8839": "supseteq;", + "8840": "nsubseteq;", + "8841": "nsupseteq;", + "8842": "subsetneq;", + "8843": "supsetneq;", + "8845": "cupdot;", + "8846": "uplus;", + "8847": "SquareSubset;", + "8848": "SquareSuperset;", + "8849": "SquareSubsetEqual;", + "8850": "SquareSupersetEqual;", + "8851": "SquareIntersection;", + "8852": "SquareUnion;", + "8853": "oplus;", + "8854": "ominus;", + "8855": "otimes;", + "8856": "osol;", + "8857": "odot;", + "8858": "ocir;", + "8859": "oast;", + "8861": "odash;", + "8862": "plusb;", + "8863": "minusb;", + "8864": "timesb;", + "8865": "sdotb;", + "8866": "vdash;", + "8867": "LeftTee;", + "8868": "top;", + "8869": "UpTee;", + "8871": "models;", + "8872": "vDash;", + "8873": "Vdash;", + "8874": "Vvdash;", + "8875": "VDash;", + "8876": "nvdash;", + "8877": "nvDash;", + "8878": "nVdash;", + "8879": "nVDash;", + "8880": "prurel;", + "8882": "vltri;", + "8883": "vrtri;", + "8884": "trianglelefteq;", + "8885": "trianglerighteq;", + "8886": "origof;", + "8887": "imof;", + "8888": "mumap;", + "8889": "hercon;", + "8890": "intercal;", + "8891": "veebar;", + "8893": "barvee;", + "8894": "angrtvb;", + "8895": "lrtri;", + "8896": "xwedge;", + "8897": "xvee;", + "8898": "xcap;", + "8899": "xcup;", + "8900": "diamond;", + "8901": "sdot;", + "8902": "Star;", + "8903": "divonx;", + "8904": "bowtie;", + "8905": "ltimes;", + "8906": "rtimes;", + "8907": "lthree;", + "8908": "rthree;", + "8909": "bsime;", + "8910": "cuvee;", + "8911": "cuwed;", + "8912": "Subset;", + "8913": "Supset;", + "8914": "Cap;", + "8915": "Cup;", + "8916": "pitchfork;", + "8917": "epar;", + "8918": "ltdot;", + "8919": "gtrdot;", + "8920": "Ll;", + "8921": "ggg;", + "8922": "LessEqualGreater;", + "8923": "gtreqless;", + "8926": "curlyeqprec;", + "8927": "curlyeqsucc;", + "8928": "nprcue;", + "8929": "nsccue;", + "8930": "nsqsube;", + "8931": "nsqsupe;", + "8934": "lnsim;", + "8935": "gnsim;", + "8936": "prnsim;", + "8937": "succnsim;", + "8938": "ntriangleleft;", + "8939": "ntriangleright;", + "8940": "ntrianglelefteq;", + "8941": "ntrianglerighteq;", + "8942": "vellip;", + "8943": "ctdot;", + "8944": "utdot;", + "8945": "dtdot;", + "8946": "disin;", + "8947": "isinsv;", + "8948": "isins;", + "8949": "isindot;", + "8950": "notinvc;", + "8951": "notinvb;", + "8953": "isinE;", + "8954": "nisd;", + "8955": "xnis;", + "8956": "nis;", + "8957": "notnivc;", + "8958": "notnivb;", + "8965": "barwedge;", + "8966": "doublebarwedge;", + "8968": "LeftCeiling;", + "8969": "RightCeiling;", + "8970": "lfloor;", + "8971": "RightFloor;", + "8972": "drcrop;", + "8973": "dlcrop;", + "8974": "urcrop;", + "8975": "ulcrop;", + "8976": "bnot;", + "8978": "profline;", + "8979": "profsurf;", + "8981": "telrec;", + "8982": "target;", + "8988": "ulcorner;", + "8989": "urcorner;", + "8990": "llcorner;", + "8991": "lrcorner;", + "8994": "sfrown;", + "8995": "ssmile;", + "9005": "cylcty;", + "9006": "profalar;", + "9014": "topbot;", + "9021": "ovbar;", + "9023": "solbar;", + "9084": "angzarr;", + "9136": "lmoustache;", + "9137": "rmoustache;", + "9140": "tbrk;", + "9141": "UnderBracket;", + "9142": "bbrktbrk;", + "9180": "OverParenthesis;", + "9181": "UnderParenthesis;", + "9182": "OverBrace;", + "9183": "UnderBrace;", + "9186": "trpezium;", + "9191": "elinters;", + "9251": "blank;", + "9416": "oS;", + "9472": "HorizontalLine;", + "9474": "boxv;", + "9484": "boxdr;", + "9488": "boxdl;", + "9492": "boxur;", + "9496": "boxul;", + "9500": "boxvr;", + "9508": "boxvl;", + "9516": "boxhd;", + "9524": "boxhu;", + "9532": "boxvh;", + "9552": "boxH;", + "9553": "boxV;", + "9554": "boxdR;", + "9555": "boxDr;", + "9556": "boxDR;", + "9557": "boxdL;", + "9558": "boxDl;", + "9559": "boxDL;", + "9560": "boxuR;", + "9561": "boxUr;", + "9562": "boxUR;", + "9563": "boxuL;", + "9564": "boxUl;", + "9565": "boxUL;", + "9566": "boxvR;", + "9567": "boxVr;", + "9568": "boxVR;", + "9569": "boxvL;", + "9570": "boxVl;", + "9571": "boxVL;", + "9572": "boxHd;", + "9573": "boxhD;", + "9574": "boxHD;", + "9575": "boxHu;", + "9576": "boxhU;", + "9577": "boxHU;", + "9578": "boxvH;", + "9579": "boxVh;", + "9580": "boxVH;", + "9600": "uhblk;", + "9604": "lhblk;", + "9608": "block;", + "9617": "blk14;", + "9618": "blk12;", + "9619": "blk34;", + "9633": "square;", + "9642": "squf;", + "9643": "EmptyVerySmallSquare;", + "9645": "rect;", + "9646": "marker;", + "9649": "fltns;", + "9651": "xutri;", + "9652": "utrif;", + "9653": "utri;", + "9656": "rtrif;", + "9657": "triangleright;", + "9661": "xdtri;", + "9662": "dtrif;", + "9663": "triangledown;", + "9666": "ltrif;", + "9667": "triangleleft;", + "9674": "lozenge;", + "9675": "cir;", + "9708": "tridot;", + "9711": "xcirc;", + "9720": "ultri;", + "9721": "urtri;", + "9722": "lltri;", + "9723": "EmptySmallSquare;", + "9724": "FilledSmallSquare;", + "9733": "starf;", + "9734": "star;", + "9742": "phone;", + "9792": "female;", + "9794": "male;", + "9824": "spadesuit;", + "9827": "clubsuit;", + "9829": "heartsuit;", + "9830": "diams;", + "9834": "sung;", + "9837": "flat;", + "9838": "natural;", + "9839": "sharp;", + "10003": "checkmark;", + "10007": "cross;", + "10016": "maltese;", + "10038": "sext;", + "10072": "VerticalSeparator;", + "10098": "lbbrk;", + "10099": "rbbrk;", + "10184": "bsolhsub;", + "10185": "suphsol;", + "10214": "lobrk;", + "10215": "robrk;", + "10216": "LeftAngleBracket;", + "10217": "RightAngleBracket;", + "10218": "Lang;", + "10219": "Rang;", + "10220": "loang;", + "10221": "roang;", + "10229": "xlarr;", + "10230": "xrarr;", + "10231": "xharr;", + "10232": "xlArr;", + "10233": "xrArr;", + "10234": "xhArr;", + "10236": "xmap;", + "10239": "dzigrarr;", + "10498": "nvlArr;", + "10499": "nvrArr;", + "10500": "nvHarr;", + "10501": "Map;", + "10508": "lbarr;", + "10509": "rbarr;", + "10510": "lBarr;", + "10511": "rBarr;", + "10512": "RBarr;", + "10513": "DDotrahd;", + "10514": "UpArrowBar;", + "10515": "DownArrowBar;", + "10518": "Rarrtl;", + "10521": "latail;", + "10522": "ratail;", + "10523": "lAtail;", + "10524": "rAtail;", + "10525": "larrfs;", + "10526": "rarrfs;", + "10527": "larrbfs;", + "10528": "rarrbfs;", + "10531": "nwarhk;", + "10532": "nearhk;", + "10533": "searhk;", + "10534": "swarhk;", + "10535": "nwnear;", + "10536": "toea;", + "10537": "tosa;", + "10538": "swnwar;", + "10547": "rarrc;", + "10549": "cudarrr;", + "10550": "ldca;", + "10551": "rdca;", + "10552": "cudarrl;", + "10553": "larrpl;", + "10556": "curarrm;", + "10557": "cularrp;", + "10565": "rarrpl;", + "10568": "harrcir;", + "10569": "Uarrocir;", + "10570": "lurdshar;", + "10571": "ldrushar;", + "10574": "LeftRightVector;", + "10575": "RightUpDownVector;", + "10576": "DownLeftRightVector;", + "10577": "LeftUpDownVector;", + "10578": "LeftVectorBar;", + "10579": "RightVectorBar;", + "10580": "RightUpVectorBar;", + "10581": "RightDownVectorBar;", + "10582": "DownLeftVectorBar;", + "10583": "DownRightVectorBar;", + "10584": "LeftUpVectorBar;", + "10585": "LeftDownVectorBar;", + "10586": "LeftTeeVector;", + "10587": "RightTeeVector;", + "10588": "RightUpTeeVector;", + "10589": "RightDownTeeVector;", + "10590": "DownLeftTeeVector;", + "10591": "DownRightTeeVector;", + "10592": "LeftUpTeeVector;", + "10593": "LeftDownTeeVector;", + "10594": "lHar;", + "10595": "uHar;", + "10596": "rHar;", + "10597": "dHar;", + "10598": "luruhar;", + "10599": "ldrdhar;", + "10600": "ruluhar;", + "10601": "rdldhar;", + "10602": "lharul;", + "10603": "llhard;", + "10604": "rharul;", + "10605": "lrhard;", + "10606": "UpEquilibrium;", + "10607": "ReverseUpEquilibrium;", + "10608": "RoundImplies;", + "10609": "erarr;", + "10610": "simrarr;", + "10611": "larrsim;", + "10612": "rarrsim;", + "10613": "rarrap;", + "10614": "ltlarr;", + "10616": "gtrarr;", + "10617": "subrarr;", + "10619": "suplarr;", + "10620": "lfisht;", + "10621": "rfisht;", + "10622": "ufisht;", + "10623": "dfisht;", + "10629": "lopar;", + "10630": "ropar;", + "10635": "lbrke;", + "10636": "rbrke;", + "10637": "lbrkslu;", + "10638": "rbrksld;", + "10639": "lbrksld;", + "10640": "rbrkslu;", + "10641": "langd;", + "10642": "rangd;", + "10643": "lparlt;", + "10644": "rpargt;", + "10645": "gtlPar;", + "10646": "ltrPar;", + "10650": "vzigzag;", + "10652": "vangrt;", + "10653": "angrtvbd;", + "10660": "ange;", + "10661": "range;", + "10662": "dwangle;", + "10663": "uwangle;", + "10664": "angmsdaa;", + "10665": "angmsdab;", + "10666": "angmsdac;", + "10667": "angmsdad;", + "10668": "angmsdae;", + "10669": "angmsdaf;", + "10670": "angmsdag;", + "10671": "angmsdah;", + "10672": "bemptyv;", + "10673": "demptyv;", + "10674": "cemptyv;", + "10675": "raemptyv;", + "10676": "laemptyv;", + "10677": "ohbar;", + "10678": "omid;", + "10679": "opar;", + "10681": "operp;", + "10683": "olcross;", + "10684": "odsold;", + "10686": "olcir;", + "10687": "ofcir;", + "10688": "olt;", + "10689": "ogt;", + "10690": "cirscir;", + "10691": "cirE;", + "10692": "solb;", + "10693": "bsolb;", + "10697": "boxbox;", + "10701": "trisb;", + "10702": "rtriltri;", + "10703": "LeftTriangleBar;", + "10704": "RightTriangleBar;", + "10716": "iinfin;", + "10717": "infintie;", + "10718": "nvinfin;", + "10723": "eparsl;", + "10724": "smeparsl;", + "10725": "eqvparsl;", + "10731": "lozf;", + "10740": "RuleDelayed;", + "10742": "dsol;", + "10752": "xodot;", + "10753": "xoplus;", + "10754": "xotime;", + "10756": "xuplus;", + "10758": "xsqcup;", + "10764": "qint;", + "10765": "fpartint;", + "10768": "cirfnint;", + "10769": "awint;", + "10770": "rppolint;", + "10771": "scpolint;", + "10772": "npolint;", + "10773": "pointint;", + "10774": "quatint;", + "10775": "intlarhk;", + "10786": "pluscir;", + "10787": "plusacir;", + "10788": "simplus;", + "10789": "plusdu;", + "10790": "plussim;", + "10791": "plustwo;", + "10793": "mcomma;", + "10794": "minusdu;", + "10797": "loplus;", + "10798": "roplus;", + "10799": "Cross;", + "10800": "timesd;", + "10801": "timesbar;", + "10803": "smashp;", + "10804": "lotimes;", + "10805": "rotimes;", + "10806": "otimesas;", + "10807": "Otimes;", + "10808": "odiv;", + "10809": "triplus;", + "10810": "triminus;", + "10811": "tritime;", + "10812": "iprod;", + "10815": "amalg;", + "10816": "capdot;", + "10818": "ncup;", + "10819": "ncap;", + "10820": "capand;", + "10821": "cupor;", + "10822": "cupcap;", + "10823": "capcup;", + "10824": "cupbrcap;", + "10825": "capbrcup;", + "10826": "cupcup;", + "10827": "capcap;", + "10828": "ccups;", + "10829": "ccaps;", + "10832": "ccupssm;", + "10835": "And;", + "10836": "Or;", + "10837": "andand;", + "10838": "oror;", + "10839": "orslope;", + "10840": "andslope;", + "10842": "andv;", + "10843": "orv;", + "10844": "andd;", + "10845": "ord;", + "10847": "wedbar;", + "10854": "sdote;", + "10858": "simdot;", + "10861": "congdot;", + "10862": "easter;", + "10863": "apacir;", + "10864": "apE;", + "10865": "eplus;", + "10866": "pluse;", + "10867": "Esim;", + "10868": "Colone;", + "10869": "Equal;", + "10871": "eDDot;", + "10872": "equivDD;", + "10873": "ltcir;", + "10874": "gtcir;", + "10875": "ltquest;", + "10876": "gtquest;", + "10877": "LessSlantEqual;", + "10878": "GreaterSlantEqual;", + "10879": "lesdot;", + "10880": "gesdot;", + "10881": "lesdoto;", + "10882": "gesdoto;", + "10883": "lesdotor;", + "10884": "gesdotol;", + "10885": "lessapprox;", + "10886": "gtrapprox;", + "10887": "lneq;", + "10888": "gneq;", + "10889": "lnapprox;", + "10890": "gnapprox;", + "10891": "lesseqqgtr;", + "10892": "gtreqqless;", + "10893": "lsime;", + "10894": "gsime;", + "10895": "lsimg;", + "10896": "gsiml;", + "10897": "lgE;", + "10898": "glE;", + "10899": "lesges;", + "10900": "gesles;", + "10901": "eqslantless;", + "10902": "eqslantgtr;", + "10903": "elsdot;", + "10904": "egsdot;", + "10905": "el;", + "10906": "eg;", + "10909": "siml;", + "10910": "simg;", + "10911": "simlE;", + "10912": "simgE;", + "10913": "LessLess;", + "10914": "GreaterGreater;", + "10916": "glj;", + "10917": "gla;", + "10918": "ltcc;", + "10919": "gtcc;", + "10920": "lescc;", + "10921": "gescc;", + "10922": "smt;", + "10923": "lat;", + "10924": "smte;", + "10925": "late;", + "10926": "bumpE;", + "10927": "preceq;", + "10928": "succeq;", + "10931": "prE;", + "10932": "scE;", + "10933": "prnE;", + "10934": "succneqq;", + "10935": "precapprox;", + "10936": "succapprox;", + "10937": "prnap;", + "10938": "succnapprox;", + "10939": "Pr;", + "10940": "Sc;", + "10941": "subdot;", + "10942": "supdot;", + "10943": "subplus;", + "10944": "supplus;", + "10945": "submult;", + "10946": "supmult;", + "10947": "subedot;", + "10948": "supedot;", + "10949": "subseteqq;", + "10950": "supseteqq;", + "10951": "subsim;", + "10952": "supsim;", + "10955": "subsetneqq;", + "10956": "supsetneqq;", + "10959": "csub;", + "10960": "csup;", + "10961": "csube;", + "10962": "csupe;", + "10963": "subsup;", + "10964": "supsub;", + "10965": "subsub;", + "10966": "supsup;", + "10967": "suphsub;", + "10968": "supdsub;", + "10969": "forkv;", + "10970": "topfork;", + "10971": "mlcp;", + "10980": "DoubleLeftTee;", + "10982": "Vdashl;", + "10983": "Barv;", + "10984": "vBar;", + "10985": "vBarv;", + "10987": "Vbar;", + "10988": "Not;", + "10989": "bNot;", + "10990": "rnmid;", + "10991": "cirmid;", + "10992": "midcir;", + "10993": "topcir;", + "10994": "nhpar;", + "10995": "parsim;", + "11005": "parsl;", + "64256": "fflig;", + "64257": "filig;", + "64258": "fllig;", + "64259": "ffilig;", + "64260": "ffllig;" +} +},{}],11:[function(require,module,exports){ +'use strict'; + +var hasOwn = Object.prototype.hasOwnProperty; +var toStr = Object.prototype.toString; +var defineProperty = Object.defineProperty; +var gOPD = Object.getOwnPropertyDescriptor; + +var isArray = function isArray(arr) { + if (typeof Array.isArray === 'function') { + return Array.isArray(arr); + } + + return toStr.call(arr) === '[object Array]'; +}; + +var isPlainObject = function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + + var hasOwnConstructor = hasOwn.call(obj, 'constructor'); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); + // Not own constructor property must be Object + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + + // Own properties are enumerated firstly, so to speed up, + // if last one is own, then all properties are own. + var key; + for (key in obj) { /**/ } + + return typeof key === 'undefined' || hasOwn.call(obj, key); +}; + +// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target +var setProperty = function setProperty(target, options) { + if (defineProperty && options.name === '__proto__') { + defineProperty(target, options.name, { + enumerable: true, + configurable: true, + value: options.newValue, + writable: true + }); + } else { + target[options.name] = options.newValue; + } +}; + +// Return undefined instead of __proto__ if '__proto__' is not an own property +var getProperty = function getProperty(obj, name) { + if (name === '__proto__') { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + // In early versions of node, obj['__proto__'] is buggy when obj has + // __proto__ as an own property. Object.getOwnPropertyDescriptor() works. + return gOPD(obj, name).value; + } + } + + return obj[name]; +}; + +module.exports = function extend() { + var options, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + + // Handle a deep copy situation + if (typeof target === 'boolean') { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { + target = {}; + } + + for (; i < length; ++i) { + options = arguments[i]; + // Only deal with non-null/undefined values + if (options != null) { + // Extend the base object + for (name in options) { + src = getProperty(target, name); + copy = getProperty(options, name); + + // Prevent never-ending loop + if (target !== copy) { + // Recurse if we're merging plain objects or arrays + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone them + setProperty(target, { name: name, newValue: extend(deep, clone, copy) }); + + // Don't bring in undefined values + } else if (typeof copy !== 'undefined') { + setProperty(target, { name: name, newValue: copy }); + } + } + } + } + } + + // Return the modified object + return target; +}; + +},{}],12:[function(require,module,exports){ +(function (global){ +/*! https://mths.be/punycode v1.4.1 by @mathias */ +;(function(root) { + + /** Detect free variables */ + var freeExports = typeof exports == 'object' && exports && + !exports.nodeType && exports; + var freeModule = typeof module == 'object' && module && + !module.nodeType && module; + var freeGlobal = typeof global == 'object' && global; + if ( + freeGlobal.global === freeGlobal || + freeGlobal.window === freeGlobal || + freeGlobal.self === freeGlobal + ) { + root = freeGlobal; + } + + /** + * The `punycode` object. + * @name punycode + * @type Object + */ + var punycode, + + /** Highest positive signed 32-bit float value */ + maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 + + /** Bootstring parameters */ + base = 36, + tMin = 1, + tMax = 26, + skew = 38, + damp = 700, + initialBias = 72, + initialN = 128, // 0x80 + delimiter = '-', // '\x2D' + + /** Regular expressions */ + regexPunycode = /^xn--/, + regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars + regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators + + /** Error messages */ + errors = { + 'overflow': 'Overflow: input needs wider integers to process', + 'not-basic': 'Illegal input >= 0x80 (not a basic code point)', + 'invalid-input': 'Invalid input' + }, + + /** Convenience shortcuts */ + baseMinusTMin = base - tMin, + floor = Math.floor, + stringFromCharCode = String.fromCharCode, + + /** Temporary variable */ + key; + + /*--------------------------------------------------------------------------*/ + + /** + * A generic error utility function. + * @private + * @param {String} type The error type. + * @returns {Error} Throws a `RangeError` with the applicable error message. + */ + function error(type) { + throw new RangeError(errors[type]); + } + + /** + * A generic `Array#map` utility function. + * @private + * @param {Array} array The array to iterate over. + * @param {Function} callback The function that gets called for every array + * item. + * @returns {Array} A new array of values returned by the callback function. + */ + function map(array, fn) { + var length = array.length; + var result = []; + while (length--) { + result[length] = fn(array[length]); + } + return result; + } + + /** + * A simple `Array#map`-like wrapper to work with domain name strings or email + * addresses. + * @private + * @param {String} domain The domain name or email address. + * @param {Function} callback The function that gets called for every + * character. + * @returns {Array} A new string of characters returned by the callback + * function. + */ + function mapDomain(string, fn) { + var parts = string.split('@'); + var result = ''; + if (parts.length > 1) { + // In email addresses, only the domain name should be punycoded. Leave + // the local part (i.e. everything up to `@`) intact. + result = parts[0] + '@'; + string = parts[1]; + } + // Avoid `split(regex)` for IE8 compatibility. See #17. + string = string.replace(regexSeparators, '\x2E'); + var labels = string.split('.'); + var encoded = map(labels, fn).join('.'); + return result + encoded; + } + + /** + * Creates an array containing the numeric code points of each Unicode + * character in the string. While JavaScript uses UCS-2 internally, + * this function will convert a pair of surrogate halves (each of which + * UCS-2 exposes as separate characters) into a single code point, + * matching UTF-16. + * @see `punycode.ucs2.encode` + * @see + * @memberOf punycode.ucs2 + * @name decode + * @param {String} string The Unicode input string (UCS-2). + * @returns {Array} The new array of code points. + */ + function ucs2decode(string) { + var output = [], + counter = 0, + length = string.length, + value, + extra; + while (counter < length) { + value = string.charCodeAt(counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + // high surrogate, and there is a next character + extra = string.charCodeAt(counter++); + if ((extra & 0xFC00) == 0xDC00) { // low surrogate + output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + // unmatched surrogate; only append this code unit, in case the next + // code unit is the high surrogate of a surrogate pair + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; + } + + /** + * Creates a string based on an array of numeric code points. + * @see `punycode.ucs2.decode` + * @memberOf punycode.ucs2 + * @name encode + * @param {Array} codePoints The array of numeric code points. + * @returns {String} The new Unicode string (UCS-2). + */ + function ucs2encode(array) { + return map(array, function(value) { + var output = ''; + if (value > 0xFFFF) { + value -= 0x10000; + output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); + value = 0xDC00 | value & 0x3FF; + } + output += stringFromCharCode(value); + return output; + }).join(''); + } + + /** + * Converts a basic code point into a digit/integer. + * @see `digitToBasic()` + * @private + * @param {Number} codePoint The basic numeric code point value. + * @returns {Number} The numeric value of a basic code point (for use in + * representing integers) in the range `0` to `base - 1`, or `base` if + * the code point does not represent a value. + */ + function basicToDigit(codePoint) { + if (codePoint - 48 < 10) { + return codePoint - 22; + } + if (codePoint - 65 < 26) { + return codePoint - 65; + } + if (codePoint - 97 < 26) { + return codePoint - 97; + } + return base; + } + + /** + * Converts a digit/integer into a basic code point. + * @see `basicToDigit()` + * @private + * @param {Number} digit The numeric value of a basic code point. + * @returns {Number} The basic code point whose value (when used for + * representing integers) is `digit`, which needs to be in the range + * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is + * used; else, the lowercase form is used. The behavior is undefined + * if `flag` is non-zero and `digit` has no uppercase form. + */ + function digitToBasic(digit, flag) { + // 0..25 map to ASCII a..z or A..Z + // 26..35 map to ASCII 0..9 + return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); + } + + /** + * Bias adaptation function as per section 3.4 of RFC 3492. + * https://tools.ietf.org/html/rfc3492#section-3.4 + * @private + */ + function adapt(delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { + delta = floor(delta / baseMinusTMin); + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); + } + + /** + * Converts a Punycode string of ASCII-only symbols to a string of Unicode + * symbols. + * @memberOf punycode + * @param {String} input The Punycode string of ASCII-only symbols. + * @returns {String} The resulting string of Unicode symbols. + */ + function decode(input) { + // Don't use UCS-2 + var output = [], + inputLength = input.length, + out, + i = 0, + n = initialN, + bias = initialBias, + basic, + j, + index, + oldi, + w, + k, + digit, + t, + /** Cached calculation results */ + baseMinusT; + + // Handle the basic code points: let `basic` be the number of input code + // points before the last delimiter, or `0` if there is none, then copy + // the first basic code points to the output. + + basic = input.lastIndexOf(delimiter); + if (basic < 0) { + basic = 0; + } + + for (j = 0; j < basic; ++j) { + // if it's not a basic code point + if (input.charCodeAt(j) >= 0x80) { + error('not-basic'); + } + output.push(input.charCodeAt(j)); + } + + // Main decoding loop: start just after the last delimiter if any basic code + // points were copied; start at the beginning otherwise. + + for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) { + + // `index` is the index of the next character to be consumed. + // Decode a generalized variable-length integer into `delta`, + // which gets added to `i`. The overflow checking is easier + // if we increase `i` as we go, then subtract off its starting + // value at the end to obtain `delta`. + for (oldi = i, w = 1, k = base; /* no condition */; k += base) { + + if (index >= inputLength) { + error('invalid-input'); + } + + digit = basicToDigit(input.charCodeAt(index++)); + + if (digit >= base || digit > floor((maxInt - i) / w)) { + error('overflow'); + } + + i += digit * w; + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + + if (digit < t) { + break; + } + + baseMinusT = base - t; + if (w > floor(maxInt / baseMinusT)) { + error('overflow'); + } + + w *= baseMinusT; + + } + + out = output.length + 1; + bias = adapt(i - oldi, out, oldi == 0); + + // `i` was supposed to wrap around from `out` to `0`, + // incrementing `n` each time, so we'll fix that now: + if (floor(i / out) > maxInt - n) { + error('overflow'); + } + + n += floor(i / out); + i %= out; + + // Insert `n` at position `i` of the output + output.splice(i++, 0, n); + + } + + return ucs2encode(output); + } + + /** + * Converts a string of Unicode symbols (e.g. a domain name label) to a + * Punycode string of ASCII-only symbols. + * @memberOf punycode + * @param {String} input The string of Unicode symbols. + * @returns {String} The resulting Punycode string of ASCII-only symbols. + */ + function encode(input) { + var n, + delta, + handledCPCount, + basicLength, + bias, + j, + m, + q, + k, + t, + currentValue, + output = [], + /** `inputLength` will hold the number of code points in `input`. */ + inputLength, + /** Cached calculation results */ + handledCPCountPlusOne, + baseMinusT, + qMinusT; + + // Convert the input in UCS-2 to Unicode + input = ucs2decode(input); + + // Cache the length + inputLength = input.length; + + // Initialize the state + n = initialN; + delta = 0; + bias = initialBias; + + // Handle the basic code points + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue < 0x80) { + output.push(stringFromCharCode(currentValue)); + } + } + + handledCPCount = basicLength = output.length; + + // `handledCPCount` is the number of code points that have been handled; + // `basicLength` is the number of basic code points. + + // Finish the basic string - if it is not empty - with a delimiter + if (basicLength) { + output.push(delimiter); + } + + // Main encoding loop: + while (handledCPCount < inputLength) { + + // All non-basic code points < n have been handled already. Find the next + // larger one: + for (m = maxInt, j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + + // Increase `delta` enough to advance the decoder's state to , + // but guard against overflow + handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + error('overflow'); + } + + delta += (m - n) * handledCPCountPlusOne; + n = m; + + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + + if (currentValue < n && ++delta > maxInt) { + error('overflow'); + } + + if (currentValue == n) { + // Represent delta as a generalized variable-length integer + for (q = delta, k = base; /* no condition */; k += base) { + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + if (q < t) { + break; + } + qMinusT = q - t; + baseMinusT = base - t; + output.push( + stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) + ); + q = floor(qMinusT / baseMinusT); + } + + output.push(stringFromCharCode(digitToBasic(q, 0))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); + delta = 0; + ++handledCPCount; + } + } + + ++delta; + ++n; + + } + return output.join(''); + } + + /** + * Converts a Punycode string representing a domain name or an email address + * to Unicode. Only the Punycoded parts of the input will be converted, i.e. + * it doesn't matter if you call it on a string that has already been + * converted to Unicode. + * @memberOf punycode + * @param {String} input The Punycoded domain name or email address to + * convert to Unicode. + * @returns {String} The Unicode representation of the given Punycode + * string. + */ + function toUnicode(input) { + return mapDomain(input, function(string) { + return regexPunycode.test(string) + ? decode(string.slice(4).toLowerCase()) + : string; + }); + } + + /** + * Converts a Unicode string representing a domain name or an email address to + * Punycode. Only the non-ASCII parts of the domain name will be converted, + * i.e. it doesn't matter if you call it with a domain that's already in + * ASCII. + * @memberOf punycode + * @param {String} input The domain name or email address to convert, as a + * Unicode string. + * @returns {String} The Punycode representation of the given domain name or + * email address. + */ + function toASCII(input) { + return mapDomain(input, function(string) { + return regexNonASCII.test(string) + ? 'xn--' + encode(string) + : string; + }); + } + + /*--------------------------------------------------------------------------*/ + + /** Define the public API */ + punycode = { + /** + * A string representing the current Punycode.js version number. + * @memberOf punycode + * @type String + */ + 'version': '1.4.1', + /** + * An object of methods to convert from JavaScript's internal character + * representation (UCS-2) to Unicode code points, and back. + * @see + * @memberOf punycode + * @type Object + */ + 'ucs2': { + 'decode': ucs2decode, + 'encode': ucs2encode + }, + 'decode': decode, + 'encode': encode, + 'toASCII': toASCII, + 'toUnicode': toUnicode + }; + + /** Expose `punycode` */ + // Some AMD build optimizers, like r.js, check for specific condition patterns + // like the following: + if ( + typeof define == 'function' && + typeof define.amd == 'object' && + define.amd + ) { + define('punycode', function() { + return punycode; + }); + } else if (freeExports && freeModule) { + if (module.exports == freeExports) { + // in Node.js, io.js, or RingoJS v0.8.0+ + freeModule.exports = punycode; + } else { + // in Narwhal or RingoJS v0.7.0- + for (key in punycode) { + punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]); + } + } + } else { + // in Rhino or a web browser + root.punycode = punycode; + } + +}(this)); + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],13:[function(require,module,exports){ +/** + * This file automatically generated from `pre-publish.js`. + * Do not manually edit. + */ + +module.exports = { + "area": true, + "base": true, + "br": true, + "col": true, + "embed": true, + "hr": true, + "img": true, + "input": true, + "keygen": true, + "link": true, + "menuitem": true, + "meta": true, + "param": true, + "source": true, + "track": true, + "wbr": true +}; + +},{}]},{},[3]); diff --git a/test/unit/utils/bundle-utils.spec.js b/test/unit/utils/bundle-utils.spec.js deleted file mode 100644 index 88aebefa7..000000000 --- a/test/unit/utils/bundle-utils.spec.js +++ /dev/null @@ -1,42 +0,0 @@ -'use strict' - -const BundleUtils = require('../../../lib/utils/bundle-utils') -const PathUtils = require('../../../lib/utils/path-utils') -const FileUtils = require('../../../lib/utils/file-utils') -const fs = require('fs') - -const sandbox = sinon.createSandbox() - -describe('BundleUtils.bundleResource', () => { - beforeEach(() => FileUtils.removeFileIfExists(PathUtils.calculateAbsolutePath('test/unit/fixtures/bundled.js'))) - - it('create bundle file in requested output path', (done) => { - BundleUtils.bundleResource('test/unit/fixtures/format-error-root.js', 'test/unit/fixtures/bundled.js') - .then(() => { - expect(fs.existsSync(PathUtils.calculateAbsolutePath('test/unit/fixtures/bundled.js'))).to.be.true - done() - }) - }).timeout(5000) -}) - -describe('BundleUtils.bundleResourceIfNotExist', () => { - beforeEach(() => { - sandbox.stub(BundleUtils, 'bundleResource').resolves() - }) - - afterEach(() => sandbox.restore()) - - it('bundle resource when output path file not exists', () => { - sandbox.stub(fs, 'existsSync').returns(false) - - BundleUtils.bundleResourceIfNotExist('context/main.js', 'static/context.js') - expect(BundleUtils.bundleResource).to.have.been.called - }) - - it('does not bundle resource when output path file exists', () => { - sandbox.stub(fs, 'existsSync').returns(true) - - BundleUtils.bundleResourceIfNotExist('context/main.js', 'static/context.js') - expect(BundleUtils.bundleResource).to.not.have.been.called - }) -})