· 8 years ago · Mar 05, 2018, 07:46 AM
1!function() {
2 /**
3 * @param {Function} dataAndEvents
4 * @return {undefined}
5 */
6 function clone(dataAndEvents) {
7 if (!s.length) {
8 compiled();
9 }
10 /** @type {Function} */
11 s[s.length] = dataAndEvents;
12 }
13 /**
14 * @return {undefined}
15 */
16 function foo() {
17 for (;l < s.length;) {
18 var i = l;
19 if (l += 1, s[i].call(), l > r) {
20 /** @type {number} */
21 var k = 0;
22 for (;k < l;k++) {
23 s[k] = s[k + l];
24 }
25 s.length -= l;
26 /** @type {number} */
27 l = 0;
28 }
29 }
30 /** @type {number} */
31 s.length = 0;
32 /** @type {number} */
33 l = 0;
34 }
35 /**
36 * @return {?}
37 */
38 function isEmpty() {
39 try {
40 return!!document.createElement.call;
41 } catch (t) {
42 return false;
43 }
44 }
45 /**
46 * @return {?}
47 */
48 function fn() {
49 if (null == fn.result) {
50 try {
51 /** @type {boolean} */
52 fn.result = !!window.addEventListener;
53 } catch (t) {
54 /** @type {boolean} */
55 fn.result = false;
56 }
57 }
58 return fn.result;
59 }
60 /**
61 * @param {Element} elem
62 * @param {string} name
63 * @return {?}
64 */
65 function getAttribute(elem, name) {
66 if (elem) {
67 return HTMLEvents < 8 && "style" === name ? elem.style.cssText : "getAttribute" in elem ? elem.getAttribute(name) : elem.attributes[name];
68 }
69 }
70 /**
71 * @param {Element} element
72 * @param {string} key
73 * @param {string} val
74 * @return {?}
75 */
76 function init(element, key, val) {
77 if (element) {
78 if (!(HTMLEvents < 8 && "style" === key)) {
79 return "setAttribute" in element ? element.setAttribute(key, val) : element.attributes[key] = val;
80 }
81 /** @type {string} */
82 element.style.cssText = val;
83 }
84 }
85 /**
86 * @param {Element} selector
87 * @param {string} attr
88 * @return {?}
89 */
90 function $(selector, attr) {
91 return getAttribute(selector, "data-" + attr);
92 }
93 /**
94 * @param {Element} value
95 * @param {string} name
96 * @param {string} v
97 * @return {?}
98 */
99 function addClass(value, name, v) {
100 return init(value, "data-" + name, v);
101 }
102 /**
103 * @param {HTMLElement} element
104 * @param {string} event
105 * @param {Function} callback
106 * @param {boolean} capture
107 * @return {?}
108 */
109 function on(element, event, callback, capture) {
110 return fn() ? element.addEventListener(event, callback, capture) : element.attachEvent("on" + event, callback);
111 }
112 /**
113 * @param {HTMLDocument} element
114 * @param {string} type
115 * @param {Function} callback
116 * @param {?} capture
117 * @return {?}
118 */
119 function addEvent(element, type, callback, capture) {
120 return fn() ? element.removeEventListener(type, callback, capture) : element.detachEvent("on" + type, callback);
121 }
122 /**
123 * @param {Array} obj
124 * @param {Function} f
125 * @param {Object} o
126 * @return {?}
127 */
128 function toArray(obj, f, o) {
129 /** @type {Array} */
130 var ret = [];
131 /** @type {number} */
132 var i = 0;
133 for (;i < obj.length;i++) {
134 ret.push(f.call(o, obj[i], i, obj));
135 }
136 return ret;
137 }
138 /**
139 * @param {?} obj
140 * @param {Function} f
141 * @param {Object} opt_obj
142 * @return {undefined}
143 */
144 function forEach(obj, f, opt_obj) {
145 var key;
146 for (key in obj) {
147 if (obj.hasOwnProperty(key)) {
148 f.call(opt_obj, obj[key], key, obj);
149 }
150 }
151 }
152 /**
153 * @param {Array} obj
154 * @param {Function} func
155 * @param {string} str
156 * @return {undefined}
157 */
158 function call(obj, func, str) {
159 /** @type {number} */
160 var i = 0;
161 for (;i < obj.length;i++) {
162 func.call(str, obj[i], i, obj);
163 }
164 }
165 /**
166 * @param {Array} array
167 * @param {Function} fn
168 * @param {Object} elems
169 * @return {?}
170 */
171 function clean(array, fn, elems) {
172 /** @type {Array} */
173 var ret = [];
174 /** @type {number} */
175 var i = 0;
176 for (;i < array.length;i++) {
177 if (fn.call(elems, array[i], i, array)) {
178 ret.push(array[i]);
179 }
180 }
181 return ret;
182 }
183 /**
184 * @param {?} obj
185 * @param {Object} source
186 * @return {?}
187 */
188 function extend(obj, source) {
189 var prop;
190 for (prop in source) {
191 if (source.hasOwnProperty(prop)) {
192 obj[prop] = source[prop];
193 }
194 }
195 return obj;
196 }
197 /**
198 * @param {?} val
199 * @return {?}
200 */
201 function isArray(val) {
202 return!!val && (val instanceof Array || "object" == typeof val && (val.hasOwnProperty("length") && !val.propertyIsEnumerable("length")));
203 }
204 /**
205 * @param {Function} fn
206 * @param {?} context
207 * @return {?}
208 */
209 function once(fn, context) {
210 return function() {
211 return fn.apply(context, arguments);
212 };
213 }
214 /**
215 * @return {?}
216 */
217 function now() {
218 return(new Date).getTime();
219 }
220 /**
221 * @param {Object} obj
222 * @return {?}
223 */
224 function keys(obj) {
225 /** @type {Array} */
226 var ret = [];
227 if (null == obj || "object" != typeof obj) {
228 return ret;
229 }
230 var k;
231 for (k in obj) {
232 if (obj.hasOwnProperty(k)) {
233 ret.push(k);
234 }
235 }
236 return ret;
237 }
238 /**
239 * @param {Array} worlds
240 * @param {(Node|string)} area
241 * @return {?}
242 */
243 function indexOfBodyArea(worlds, area) {
244 /** @type {number} */
245 var i = worlds.length - 1;
246 for (;i >= 0;i--) {
247 if (area === worlds[i]) {
248 return i;
249 }
250 }
251 return-1;
252 }
253 /**
254 * @return {?}
255 */
256 function t() {
257 return null == t.n && (t.n = 0), t.n += 1, t.n;
258 }
259 /**
260 * @param {string} data
261 * @param {string} boundary
262 * @return {?}
263 */
264 function done(data, boundary) {
265 var e;
266 var args;
267 var query;
268 var value;
269 /** @type {Array} */
270 var errors = [];
271 var h = {};
272 var parser = new DOMParser;
273 return parser.initWithBoundary(boundary), parser.onPartBegin = function() {
274 e = {};
275 h = {};
276 /** @type {string} */
277 query = "";
278 /** @type {string} */
279 value = "";
280 /** @type {string} */
281 args = "";
282 }, parser.onHeaderField = function(b, start, end) {
283 query = b.slice(start, end);
284 }, parser.onHeaderValue = function(end, start, args) {
285 value = end.slice(start, args);
286 }, parser.onHeaderEnd = function() {
287 h[query.toLowerCase()] = value;
288 }, parser.onPartData = function(b, start, end) {
289 args = args.concat(b.slice(start, end));
290 }, parser.onPartEnd = function() {
291 e.data = args;
292 e.headers = h;
293 errors.push(e);
294 }, parser.write(data), parser.end(), errors;
295 }
296 /**
297 * @param {Object} settings
298 * @return {?}
299 */
300 function load(settings) {
301 var suiteView = settings.headers || {};
302 var method = settings.method || "get";
303 var data = "get" !== method ? (settings.data || "") + "\r\n" : function() {
304 /** @type {Array} */
305 var tagNameArr = [];
306 return forEach(settings.data || {}, function(value, sectionName) {
307 if (isArray(value)) {
308 call(value, function(key) {
309 tagNameArr.push(encodeURIComponent(sectionName) + "[]=" + encodeURIComponent(key));
310 });
311 } else {
312 tagNameArr.push(encodeURIComponent(sectionName) + "=" + encodeURIComponent(value));
313 }
314 }), tagNameArr.join("&").replace(/%20/g, "+");
315 }();
316 /** @type {string} */
317 var notExistIP = ("/" === settings.url.substr(0, 1) ? window.location.protocol + "//" + window.location.host : "") + settings.url + ("get" === method && data.length ? "?" + data : "");
318 /** @type {boolean} */
319 var async = false !== settings.async;
320 var error = settings.complete || noop;
321 var done = settings.error || noop;
322 var xhr = request();
323 /**
324 * @return {undefined}
325 */
326 var onError = function() {
327 var resp = xhr.responseText;
328 error(resp, xhr);
329 };
330 return xhr.onreadystatechange = function() {
331 try {
332 var e;
333 var s = xhr.readyState;
334 try {
335 e = xhr.status;
336 } catch (n) {
337 }
338 if (e && e > 399) {
339 /** @type {function (): undefined} */
340 xhr.onreadystatechange = noop;
341 done(e);
342 } else {
343 if (4 === s) {
344 onError();
345 }
346 }
347 } catch (ex) {
348 done("Uncaught exception while attempting to contact the cloud: " + ex.message);
349 /** @type {function (): undefined} */
350 xhr.onreadystatechange = noop;
351 }
352 }, xhr.open(method, notExistIP, async), forEach(suiteView, function(value, name) {
353 xhr.setRequestHeader(name, value);
354 }), xhr.send(data || undefined), xhr;
355 }
356 /**
357 * @return {undefined}
358 */
359 function noop() {
360 }
361 /**
362 * @param {Object} object
363 * @param {Function} callback
364 * @return {undefined}
365 */
366 function save(object, callback) {
367 /** @type {boolean} */
368 var streaming = !path;
369 var result = destination;
370 var url = bagId || "/cdn-cgi/pe/bag2";
371 /**
372 * @param {string} name
373 * @param {string} value
374 * @param {string} result
375 * @param {boolean} recurring
376 * @return {undefined}
377 */
378 var cb = function(name, value, result, recurring) {
379 object[name](value, result, recurring);
380 };
381 /**
382 * @return {undefined}
383 */
384 var then = function() {
385 callback();
386 };
387 var actual = keys(object);
388 if (streaming) {
389 actual = clean(actual, function(fn) {
390 var id = requestAnimationFrame(fn);
391 var body = store.getItem(id);
392 if (body) {
393 try {
394 return!(body = JSON.parse(body)).version || (body.version !== version || (cb(fn, body.contents, body.meta[3], false), false));
395 } catch (r) {
396 stringify("Stored item with key " + id + " was corrupt. Purging...");
397 store.removeItem(id);
398 }
399 }
400 return true;
401 });
402 }
403 if (actual.length) {
404 (function callback() {
405 /** @type {function (): undefined} */
406 var fn = callback;
407 var suiteView = actual.splice(0, 16);
408 var settings = {};
409 settings.data = {};
410 settings.data.r = suiteView;
411 settings.headers = {};
412 settings.headers["PE-Token"] = result;
413 settings.url = url;
414 /**
415 * @param {string} status
416 * @return {undefined}
417 */
418 settings.error = function(status) {
419 stringify("Error retrieving items from the cloud. Status code: " + status);
420 call(suiteView, function(evt) {
421 cb(evt, "", status, false);
422 });
423 then();
424 };
425 /**
426 * @param {string} err
427 * @param {Object} xhr
428 * @return {undefined}
429 */
430 settings.complete = function(err, xhr) {
431 var boundary;
432 if (!(boundary = xhr.getResponseHeader("Content-Type").match(/boundary="(.*)"/)[1])) {
433 call(suiteView, function(evt) {
434 cb(evt, "", xhr.status, false);
435 });
436 }
437 call(done(err, boundary), function(options) {
438 var expectationResult = options.headers["x-cf-status"];
439 /** @type {number} */
440 var ttl = 1E3 * options.headers["x-cf-max-age"] || 72E5;
441 if (expectationResult < 310) {
442 countComplete({
443 url : options.headers["x-cf-url"],
444 contents : options.data,
445 version : version,
446 ctime : now(),
447 stime : now(),
448 ttl : ttl,
449 meta : [null, null, null, expectationResult]
450 });
451 cb(options.headers["x-cf-url"], options.data, expectationResult, "true" === options.headers["x-cf-error"]);
452 } else {
453 cb(options.headers["x-cf-url"], "", expectationResult, "true" === options.headers["x-cf-error"]);
454 }
455 });
456 if (actual.length) {
457 fn();
458 } else {
459 then();
460 }
461 };
462 load(settings);
463 })();
464 } else {
465 then();
466 }
467 }
468 /**
469 * @param {(Array|number)} key
470 * @return {?}
471 */
472 function next(key) {
473 return destination && false !== bagId ? isint.test(key) ? Q.reject(new Error("Blacklisted URL; Bailing from bag")) : key.length > 2048 ? Q.reject(new Error("Provided URL exceeds maximum allowed length of 2048 bytes.")) : (key = trim(key), memory[key] = memory[key] || function(isXML, c) {
474 /** @type {number} */
475 c = parseInt(c) || 500;
476 if (defers[key]) {
477 if (c > 499 && c < 803 || !isXML) {
478 defers[key].reject(new Error("Script proxy demands script resolution failover."));
479 } else {
480 defers[key].resolve(isXML);
481 }
482 }
483 delete defers[key];
484 }, bt++ || clone(function() {
485 /** @type {number} */
486 bt = 0;
487 save(memory, function() {
488 });
489 memory = {};
490 }), (defers[key] = defers[key] || Q.defer()).promise) : Q.reject(new Error("Bag disabled"));
491 }
492 /**
493 * @param {Element} node
494 * @param {string} url
495 * @return {?}
496 */
497 function loadScript(node, url) {
498 var scripts;
499 var elem;
500 /**
501 * @return {undefined}
502 */
503 var load = function() {
504 if (!("readyState" in script && "loaded" !== script.readyState)) {
505 callback('Lost script from "' + url + '" is done recovering.');
506 invokeDfd.resolve();
507 loadScript();
508 }
509 };
510 /**
511 * @return {undefined}
512 */
513 var handler = function() {
514 stringify('Lost script from "' + url + '" errored out during recovery.');
515 invokeDfd.resolve();
516 loadScript();
517 };
518 /**
519 * @return {undefined}
520 */
521 var loadScript = function() {
522 addEvent(script, "load", load);
523 addEvent(script, "readystatechange", load);
524 addEvent(script, "error", handler);
525 };
526 var invokeDfd = Q.defer();
527 var script = _createElement("script");
528 return node.parentNode || (elem = (scripts = document.getElementsByTagName("script", true))[scripts.length - 1]).parentNode.insertBefore(node, elem.nextSibling), node.parentNode.insertBefore(script, node.nextSibling), on(script, "load", load), on(script, "readystatechange", load), on(script, "error", handler), callback('Attempting to recover script from "' + url + '"'), script.type = "text/javascript", script.src = url, setTimeout(function() {
529 loadScript();
530 invokeDfd.resolve();
531 }, 1E4), invokeDfd.promise;
532 }
533 /**
534 * @param {?} obj
535 * @return {undefined}
536 */
537 function getter(obj) {
538 out = obj;
539 }
540 /**
541 * @param {Element} node
542 * @param {?} item
543 * @return {?}
544 */
545 function run(node, item) {
546 /**
547 * @return {undefined}
548 */
549 var finish = function() {
550 if (s.parentNode) {
551 s.parentNode.replaceChild(node, s);
552 }
553 };
554 var source = $(node, "rocketsrc");
555 var value = source ? trim(source) : "";
556 /** @type {Text} */
557 var s = document.createTextNode("");
558 var defer = Q.ref();
559 /** @type {Array} */
560 var paramNames = [];
561 /** @type {null} */
562 var context = null;
563 var invokeDfd = Q.defer();
564 /**
565 * @param {string} a
566 * @return {?}
567 */
568 var f = function(a) {
569 return/^\s*(\x3c!--)\s*/.test(a) && (callback("Applying epic hack for inline comment removal!"), a = a.replace(/^\s*\x3c!--|--\x3e\s*$/g, "/* ROCKET: Removed HTML Comment */")), a += "\n//# sourceURL=" + (value || "inline-cloudflare-rocketloader-executed-" + t() + ".js") + "\n";
570 };
571 var self = {
572 /**
573 * @return {undefined}
574 */
575 bookmark : function() {
576 if (node.parentNode) {
577 node.parentNode.replaceChild(s, node);
578 }
579 },
580 /** @type {function (): undefined} */
581 restore : finish,
582 /**
583 * @return {?}
584 */
585 executeSubscripts : function() {
586 return paramNames.length && call(paramNames, function(command) {
587 defer = defer.then(function() {
588 return item.setExecutingScript(command), command.execute();
589 });
590 }), paramNames = [], defer;
591 },
592 /**
593 * @return {?}
594 */
595 execute : function() {
596 return promise.then(function(a) {
597 a = f(a);
598 finish();
599 callback("Executing " + self.toString());
600 try {
601 resolve(a);
602 } catch (ex) {
603 stringify("Rocket failed to execute a script. " + ex.message);
604 }
605 return invokeDfd.resolve(), out.flush(), self.executeSubscripts();
606 }, function(m1) {
607 return stringify("Failed to resolve text content for " + self.toString() + ". " + m1.message), finish(), loadScript(node, value).then(function() {
608 return invokeDfd.resolve(), out.flush(), self.executeSubscripts();
609 });
610 });
611 },
612 /**
613 * @return {?}
614 */
615 getSource : function() {
616 return value;
617 },
618 /**
619 * @return {?}
620 */
621 isExternal : function() {
622 return!!value;
623 },
624 /**
625 * @return {?}
626 */
627 isAttached : function() {
628 return!!node.parentNode;
629 },
630 /**
631 * @param {?} fn
632 * @return {undefined}
633 */
634 after : function(fn) {
635 /** @type {DocumentFragment} */
636 var pdataCur = document.createDocumentFragment();
637 context = context || node;
638 (function process(collection, handler, data) {
639 call(handler, function(obj, method) {
640 var that = collection[method] || {
641 children : []
642 };
643 var node = that.node;
644 /** @type {DocumentFragment} */
645 var root = data;
646 for (;!parse(obj.type, root.nodeName);) {
647 /** @type {(Node|null)} */
648 root = root.parentNode;
649 }
650 if (!node) {
651 node = create(obj, root);
652 }
653 if ("comment" !== obj.type && "text" !== obj.type || ("script" !== root.nodeName.toLowerCase() && "style" !== root.nodeName.toLowerCase() || 8 !== HTMLEvents)) {
654 /** @type {(Node|null)} */
655 obj.node = root.appendChild(node);
656 } else {
657 obj.node = node;
658 root.text = node.nodeValue;
659 }
660 if (obj.children) {
661 process(that.children, obj.children, node);
662 }
663 if ("script" === obj.type || "tag" === obj.type && "script" === obj.name) {
664 paramNames.push(run(node, item));
665 }
666 });
667 })([], fn, pdataCur);
668 node.parentNode.insertBefore(pdataCur, context.nextSibling);
669 context = context.nextSibling;
670 },
671 /**
672 * @return {?}
673 */
674 finishExecuting : function() {
675 return invokeDfd.promise;
676 },
677 /**
678 * @return {?}
679 */
680 resolveText : function() {
681 return promise;
682 },
683 /**
684 * @return {string}
685 */
686 toString : function() {
687 return self.isExternal() ? '"' + value + '"' : "inline script beginning with: " + (node.text || (node.textContent || "")).substring(0, 50).replace(/\s+/g, " ");
688 }
689 };
690 var promise = function() {
691 var results = Q.defer();
692 if (callback("Resolving text content for " + self.toString()), self.isExternal()) {
693 results.resolve(next(value));
694 results.promise.then(function() {
695 callback("Text content resolved for " + self.toString());
696 });
697 } else {
698 /** @type {string} */
699 var result = "";
700 if (0 !== node.childNodes.length) {
701 call(node.childNodes, function(attribute) {
702 result += attribute.nodeValue;
703 }, result);
704 } else {
705 result = node.text || (node.textContent || "");
706 }
707 results.resolve(result);
708 }
709 return results.promise;
710 }();
711 if (addClass(node, "rocketoptimized", "true"), 8 === HTMLEvents) {
712 var html = node.getAttribute;
713 var parent = node.hasAttribute;
714 /**
715 * @param {string} name
716 * @return {?}
717 */
718 node.getAttribute = function(name) {
719 return "src" === name ? value : html.call(node, name);
720 };
721 /**
722 * @param {string} element
723 * @return {?}
724 */
725 node.hasAttribute = function(element) {
726 return "src" === element ? value : parent.call(node, element);
727 };
728 get(node, "src", {
729 /**
730 * @param {string} elements
731 * @return {undefined}
732 */
733 set : function(elements) {
734 /** @type {string} */
735 value = elements;
736 addClass(node, "rocketsrc", elements);
737 },
738 /**
739 * @return {?}
740 */
741 get : function() {
742 return value;
743 }
744 });
745 }
746 return self;
747 }
748 /**
749 * @param {Object} a
750 * @param {?} config
751 * @return {?}
752 */
753 function remove(a, config) {
754 /** @type {Object} */
755 var target = a;
756 var listeners = {};
757 var c = {};
758 var special = {};
759 var element = {};
760 var cache = {};
761 /** @type {boolean} */
762 var isRestored = false;
763 /**
764 * @param {string} key
765 * @param {?} handler
766 * @return {undefined}
767 */
768 var add = function(key, handler) {
769 /** @type {Arguments} */
770 var args = arguments;
771 var name = /^on/.test(key) ? key.substring(2) : key;
772 var callbacks = listeners[name];
773 if (callbacks) {
774 callback(name + " handler added by " + config.getExecutingScript().toString());
775 callbacks.push(args);
776 } else {
777 if (fn()) {
778 element.addEventListener.apply(target, args);
779 } else {
780 try {
781 element.attachEvent.apply(target, args);
782 } catch (l) {
783 element.attachEvent(key, handler);
784 }
785 }
786 }
787 };
788 /**
789 * @param {string} type
790 * @param {?} func
791 * @return {undefined}
792 */
793 var init = function(type, func) {
794 /** @type {Arguments} */
795 var args = arguments;
796 var event = /^on/.test(type) ? type.substring(2) : type;
797 /** @type {boolean} */
798 var c = false;
799 var callbacks = listeners[event];
800 if (callbacks) {
801 call(callbacks, function(results, index) {
802 return results.length === args.length && (call(results, function(a, i) {
803 if (a !== args[i]) {
804 return false;
805 }
806 if (i === results.length - 1) {
807 callbacks.splice(index, 1);
808 /** @type {boolean} */
809 c = true;
810 }
811 }), !c);
812 });
813 } else {
814 if (fn()) {
815 element.removeEventListener.apply(target, args);
816 } else {
817 try {
818 element.detachEvent.apply(target, args);
819 } catch (l) {
820 element.detachEvent(type, func);
821 }
822 }
823 }
824 };
825 /**
826 * @param {string} name
827 * @param {Function} handler
828 * @return {undefined}
829 */
830 var remove = function(name, handler) {
831 var keys = name.split(".");
832 var k = keys[keys.length - 1];
833 var obj = target;
834 /** @type {number} */
835 var i = 0;
836 for (;i < keys.length - 1 && keys[i] in obj;i++) {
837 obj = obj[keys[i]];
838 }
839 if (k in obj) {
840 element[name] = obj[k];
841 /**
842 * @param {?} selector
843 * @param {?} fn
844 * @param {?} callback
845 * @param {?} params
846 * @param {?} e
847 * @return {?}
848 */
849 obj[k] = function(selector, fn, callback, params, e) {
850 if (config.getActivated()) {
851 return handler.apply(obj, arguments);
852 }
853 try {
854 return element[name].apply(obj, arguments);
855 } catch (l) {
856 return element[name](selector, fn, callback, params, e);
857 }
858 };
859 }
860 };
861 /**
862 * @param {string} prop
863 * @param {Function} getter
864 * @param {Function} setter
865 * @return {undefined}
866 */
867 var defineProperty = function(prop, getter, setter) {
868 if (prop in target) {
869 var descriptor = defineProperty(target, prop) || {};
870 if (getter || setter) {
871 cache[prop] = {
872 get : descriptor.get,
873 set : descriptor.set,
874 writable : descriptor.writable,
875 value : descriptor.value
876 };
877 if (getter) {
878 /** @type {Function} */
879 descriptor.get = getter;
880 }
881 if (setter) {
882 /** @type {Function} */
883 descriptor.set = setter;
884 }
885 /** @type {null} */
886 descriptor.value = null;
887 if (HTMLEvents) {
888 delete descriptor.writable;
889 delete descriptor.enumerable;
890 delete descriptor.value;
891 }
892 get(target, prop, descriptor);
893 }
894 }
895 };
896 /**
897 * @param {string} type
898 * @return {?}
899 */
900 var createEvent = function(type) {
901 var e = HTMLEvents < 9 ? document.createEventObject() : document.createEvent("HTMLEvents");
902 return HTMLEvents < 9 ? (e = document.createEventObject(), get(e, "type", {
903 /**
904 * @return {?}
905 */
906 get : function() {
907 return type;
908 }
909 })) : e.initEvent(type, true, false), wrap && (e = walk(e)), get(e, "target", {
910 /**
911 * @return {?}
912 */
913 get : function() {
914 return target;
915 }
916 }), e;
917 };
918 return remove("addEventListener", add), remove("attachEvent", add), remove("removeEventListener", init), remove("detachEvent", init), {
919 /** @type {function (string, Function): undefined} */
920 wrapNativeMethod : remove,
921 /**
922 * @return {undefined}
923 */
924 restoreNativeMethods : function() {
925 forEach(element, function(val, pair) {
926 var methodNames = pair.split(".");
927 var propname = methodNames[methodNames.length - 1];
928 var obj = target;
929 /** @type {number} */
930 var i = 0;
931 for (;i < methodNames.length - 1 && methodNames[i] in obj;i++) {
932 obj = obj[methodNames[i]];
933 }
934 obj[propname] = val;
935 });
936 /** @type {boolean} */
937 isRestored = true;
938 },
939 /**
940 * @return {undefined}
941 */
942 restoreNativeProperties : function() {
943 forEach(cache, function(User, key) {
944 var prop = defineProperty(target, key);
945 prop.get = User.get;
946 prop.set = User.set;
947 get(target, key, prop);
948 });
949 },
950 /**
951 * @return {undefined}
952 */
953 restore : function() {
954 /** @type {boolean} */
955 isRestored = true;
956 },
957 /**
958 * @return {?}
959 */
960 isRestored : function() {
961 return isRestored;
962 },
963 /** @type {function (string, Function, Function): undefined} */
964 wrapNativeProperty : defineProperty,
965 /** @type {function (string): ?} */
966 createEvent : createEvent,
967 /**
968 * @param {string} type
969 * @return {undefined}
970 */
971 deferEvent : function(type) {
972 var eventName = "on" + type.toLowerCase();
973 var addEventListener = element.addEventListener || element.attachEvent;
974 /**
975 * @param {?} event
976 * @return {undefined}
977 */
978 var touchstart = function captureHandler(event) {
979 /** @type {function (?): undefined} */
980 event.captureHandler = captureHandler;
981 special[type] = event;
982 };
983 if (defineProperty(eventName, function() {
984 return c[eventName];
985 }, function(value) {
986 c[eventName] = value;
987 }), addEventListener) {
988 if (listeners[type] || (listeners[type] = []), fn()) {
989 addEventListener.call(target, type, touchstart, true);
990 } else {
991 try {
992 addEventListener.call(target, eventName, touchstart);
993 } catch (l) {
994 addEventListener(eventName, touchstart);
995 }
996 }
997 }
998 },
999 /**
1000 * @param {string} type
1001 * @param {?} data
1002 * @return {undefined}
1003 */
1004 fireEvent : function(type, data) {
1005 var method = "on" + type.toLowerCase();
1006 var callback = element.removeEventListener || element.detachEvent;
1007 var event = data || special[type];
1008 if ("DOMContentLoaded" === type && (listeners[type].length && (!event && ((event = createEvent(type)).captureHandler = function() {
1009 }))), HTMLEvents < 9 && (target === window && ("load" === type && (listeners[type].length && ((event = createEvent(type)).captureHandler = function() {
1010 })))), event) {
1011 if (call(listeners[type] || [], function(next) {
1012 var elems = element.attachEvent ? window : target;
1013 var fn = next[1];
1014 try {
1015 fn.call(elems, event);
1016 } catch (obj) {
1017 stringify(obj.message);
1018 }
1019 }), target[method]) {
1020 try {
1021 target[method].call(target, event);
1022 } catch (pdataCur) {
1023 stringify(pdataCur);
1024 }
1025 }
1026 if (fn()) {
1027 callback.call(target, type, event.captureHandler, true);
1028 } else {
1029 try {
1030 callback.call(target, method, event.captureHandler);
1031 } catch (l) {
1032 callback(method, event.captureHandler);
1033 }
1034 }
1035 }
1036 },
1037 /**
1038 * @return {?}
1039 */
1040 getTarget : function() {
1041 return target;
1042 },
1043 /**
1044 * @param {string} property
1045 * @return {?}
1046 */
1047 getNativeMethod : function(property) {
1048 return element[property];
1049 }
1050 };
1051 }
1052 /**
1053 * @param {string} node
1054 * @param {?} item
1055 * @return {?}
1056 */
1057 function bind(node, item) {
1058 /** @type {string} */
1059 var p = node;
1060 var self = remove(wrap ? walk(node) : node, item);
1061 /** @type {string} */
1062 var ret = "loading";
1063 /** @type {string} */
1064 var query = "";
1065 /** @type {string} */
1066 var result = "";
1067 /**
1068 * @param {string} options
1069 * @return {undefined}
1070 */
1071 var run = function(options) {
1072 if (query !== options) {
1073 callback("Appending script-inserted script to execution queue.");
1074 addClass(node, "rocketsrc", options);
1075 var group = run(node, item);
1076 item.pushScript(group);
1077 group.finishExecuting().then(function() {
1078 self.load();
1079 });
1080 }
1081 /** @type {string} */
1082 query = options;
1083 };
1084 return extend(self, {
1085 /**
1086 * @return {undefined}
1087 */
1088 load : function() {
1089 var ev = self.createEvent(HTMLEvents < 9 ? "readystatechange" : "load");
1090 /** @type {string} */
1091 ret = "complete";
1092 var item = ev.target;
1093 get(ev, "readyState", {
1094 /**
1095 * @return {?}
1096 */
1097 get : function() {
1098 return ret;
1099 }
1100 });
1101 get(ev, "currentTarget", {
1102 /**
1103 * @return {?}
1104 */
1105 get : function() {
1106 return item;
1107 }
1108 });
1109 get(ev, "srcElement", {
1110 /**
1111 * @return {?}
1112 */
1113 get : function() {
1114 return item;
1115 }
1116 });
1117 self.fireEvent(ev.type, ev);
1118 },
1119 /**
1120 * @return {undefined}
1121 */
1122 fail : function() {
1123 self.fireEvent("error");
1124 }
1125 }), self.deferEvent("load"), self.deferEvent("readystatechange"), self.deferEvent("error"), self.wrapNativeProperty("readyState", function() {
1126 return ret;
1127 }, function() {
1128 }), self.wrapNativeMethod("getAttribute", function(string) {
1129 return "src" === string ? query : self.getNativeMethod("getAttribute").apply(p, arguments);
1130 }), self.wrapNativeMethod("setAttribute", function(string, action) {
1131 return "src" === string ? run(action) : self.getNativeMethod("setAttribute").apply(p, arguments);
1132 }), self.wrapNativeProperty("attributes.src", function() {
1133 return query;
1134 }, function(send) {
1135 run(send);
1136 }), self.wrapNativeProperty("src", function() {
1137 return query;
1138 }, function(send) {
1139 run(send);
1140 }), self.wrapNativeProperty("text", function() {
1141 return result;
1142 }, function(subKey) {
1143 if (result = subKey, !query) {
1144 try {
1145 resolve(result);
1146 } catch (obj) {
1147 stringify(obj.message);
1148 }
1149 }
1150 return result;
1151 }), self.wrapNativeProperty("innerText", function() {
1152 return result;
1153 }, function(subKey) {
1154 if (result = subKey, !query) {
1155 try {
1156 resolve(result);
1157 } catch (obj) {
1158 stringify(obj.message);
1159 }
1160 }
1161 return result;
1162 }), self.wrapNativeProperty("innerHTML", function() {
1163 return result;
1164 }, function(subKey) {
1165 if (result = subKey, !query) {
1166 try {
1167 resolve(result);
1168 } catch (obj) {
1169 stringify(obj.message);
1170 }
1171 }
1172 return result;
1173 }), self;
1174 }
1175 var data = window.__cfRocketOptions || {};
1176 var path = data.byc;
1177 var destination = data.petok;
1178 var bagId = data.bag;
1179 var param = data.p;
1180 var verbose = data.verbose;
1181 var client = {
1182 history : []
1183 };
1184 /**
1185 * @param {string} message
1186 * @param {number} c
1187 * @return {undefined}
1188 */
1189 client.log = function(message, c) {
1190 var e = {};
1191 /** @type {string} */
1192 e.message = message;
1193 /** @type {number} */
1194 e.category = c;
1195 client.history.push(e);
1196 };
1197 var compiled;
1198 /**
1199 * @param {string} reply
1200 * @param {number} __
1201 * @param {boolean} success
1202 * @return {undefined}
1203 */
1204 var callback = function(reply, __, success) {
1205 if (verbose) {
1206 try {
1207 console.log("[ CLOUDFLARE ] " + reply);
1208 } catch (r) {
1209 }
1210 if (false !== success) {
1211 client.log(reply, 1 | __);
1212 }
1213 }
1214 };
1215 /**
1216 * @param {string} data
1217 * @param {number} obj
1218 * @param {boolean} space
1219 * @return {undefined}
1220 */
1221 var stringify = function(data, obj, space) {
1222 if ("number" == typeof window.__cfErrCount && window.__cfErrCount++, verbose) {
1223 try {
1224 console.error("[ CLOUDFLARE ] " + data);
1225 } catch (r) {
1226 callback(data, 4 | obj, false);
1227 }
1228 if (false !== space) {
1229 client.log(data, 4 | obj);
1230 }
1231 }
1232 };
1233 /** @type {Array} */
1234 var s = [];
1235 /** @type {number} */
1236 var l = 0;
1237 /** @type {number} */
1238 var r = 1024;
1239 var opts = self.MutationObserver || self.WebKitMutationObserver;
1240 compiled = "function" == typeof opts ? function() {
1241 /** @type {number} */
1242 var data = 1;
1243 /** @type {MutationObserver} */
1244 var s = new opts(foo);
1245 /** @type {Text} */
1246 var input = self.document.createTextNode("");
1247 return s.observe(input, {
1248 characterData : true
1249 }), function() {
1250 /** @type {number} */
1251 data = -data;
1252 /** @type {number} */
1253 input.data = data;
1254 };
1255 }() : function() {
1256 /**
1257 * @return {undefined}
1258 */
1259 function run() {
1260 clearTimeout(to);
1261 clearInterval(interval);
1262 foo();
1263 }
1264 /** @type {number} */
1265 var to = setTimeout(run, 0);
1266 /** @type {number} */
1267 var interval = setInterval(run, 50);
1268 };
1269 clone.requestFlush = compiled;
1270 var obj;
1271 var Q = function(nextTick) {
1272 /**
1273 * @param {?} value
1274 * @return {?}
1275 */
1276 function identity(value) {
1277 return value;
1278 }
1279 /**
1280 * @return {?}
1281 */
1282 function defer() {
1283 var object;
1284 /** @type {Array} */
1285 var scripts = [];
1286 var deferred = create(defer.prototype);
1287 var promise = create(Promise.prototype);
1288 /**
1289 * @return {undefined}
1290 */
1291 promise.promiseSend = function() {
1292 /** @type {Array.<?>} */
1293 var args = __slice.call(arguments);
1294 if (scripts) {
1295 scripts.push(args);
1296 } else {
1297 nextTick(function() {
1298 object.promiseSend.apply(object, args);
1299 });
1300 }
1301 };
1302 /**
1303 * @return {?}
1304 */
1305 promise.valueOf = function() {
1306 return scripts ? promise : object.valueOf();
1307 };
1308 /**
1309 * @param {?} value
1310 * @return {?}
1311 */
1312 var resolve = function(value) {
1313 if (scripts) {
1314 return object = resolve(value), jQuery.call(scripts, function(dataAndEvents, pending) {
1315 nextTick(function() {
1316 object.promiseSend.apply(object, pending);
1317 });
1318 }, void 0), scripts = void 0, object;
1319 }
1320 };
1321 return deferred.promise = freeze(promise), deferred.resolve = resolve, deferred.reject = function(reason) {
1322 return resolve(reject(reason));
1323 }, deferred;
1324 }
1325 /**
1326 * @param {undefined} element
1327 * @param {Function} fallback
1328 * @param {Function} valueOf
1329 * @return {?}
1330 */
1331 function Promise(element, fallback, valueOf) {
1332 if (void 0 === fallback) {
1333 /**
1334 * @param {string} op
1335 * @return {?}
1336 */
1337 fallback = function(op) {
1338 return reject("Promise does not support operation: " + op);
1339 };
1340 }
1341 var promise = create(Promise.prototype);
1342 return promise.promiseSend = function(op, resolved) {
1343 var result;
1344 /** @type {Array.<?>} */
1345 var args = __slice.call(arguments, 2);
1346 try {
1347 result = element[op] ? element[op].apply(element, args) : fallback.apply(element, [op].concat(args));
1348 } catch (exception) {
1349 result = reject(exception);
1350 }
1351 return(resolved || identity)(result);
1352 }, valueOf && (promise.valueOf = valueOf), freeze(promise);
1353 }
1354 /**
1355 * @param {boolean} object
1356 * @return {?}
1357 */
1358 function isPromise(object) {
1359 return object && "function" == typeof object.promiseSend;
1360 }
1361 /**
1362 * @param {number} object
1363 * @return {?}
1364 */
1365 function isRejected(object) {
1366 return void 0 !== (object = valueOf(object)) && (null !== object && !!object.promiseRejected);
1367 }
1368 /**
1369 * @param {string} reason
1370 * @return {?}
1371 */
1372 function reject(reason) {
1373 var activeClassName = {};
1374 return activeClassName.when = function(rejected) {
1375 return rejected ? rejected(reason) : reject(reason);
1376 }, Promise(activeClassName, function(dataAndEvents) {
1377 return reject(reason);
1378 }, function() {
1379 var rejection = create(reject.prototype);
1380 return rejection.promiseRejected = true, rejection.reason = reason, rejection;
1381 });
1382 }
1383 /**
1384 * @param {Object} object
1385 * @return {?}
1386 */
1387 function resolve(object) {
1388 if (isPromise(object)) {
1389 return object;
1390 }
1391 if (object && "function" == typeof object.then) {
1392 var result = defer();
1393 return object.then(result.resolve, result.reject), result.promise;
1394 }
1395 var self = {};
1396 return self.when = function(rejected) {
1397 return object;
1398 }, self.get = function(param) {
1399 return object[param];
1400 }, self.put = function(key, value) {
1401 return object[key] = value;
1402 }, self.del = function(key) {
1403 return delete object[key];
1404 }, self.post = function(func, args) {
1405 return object[func].apply(object, args);
1406 }, self.apply = function(a, args) {
1407 return object.apply(a, args);
1408 }, self.keys = function() {
1409 return keys(object);
1410 }, Promise(self, void 0, function() {
1411 return object;
1412 });
1413 }
1414 /**
1415 * @param {?} value
1416 * @param {Function} fulfilled
1417 * @param {Function} rejected
1418 * @return {?}
1419 */
1420 function when(value, fulfilled, rejected) {
1421 /**
1422 * @param {HTMLElement} value
1423 * @return {?}
1424 */
1425 function _fulfilled(value) {
1426 try {
1427 return fulfilled ? fulfilled(value) : value;
1428 } catch (exception) {
1429 return reject(exception);
1430 }
1431 }
1432 /**
1433 * @param {string} exception
1434 * @return {?}
1435 */
1436 function _rejected(exception) {
1437 try {
1438 return rejected ? rejected(exception) : reject(exception);
1439 } catch (newException) {
1440 return reject(newException);
1441 }
1442 }
1443 var deferred = defer();
1444 /** @type {boolean} */
1445 var l = false;
1446 return nextTick(function() {
1447 resolve(value).promiseSend("when", function(value) {
1448 if (!l) {
1449 /** @type {boolean} */
1450 l = true;
1451 deferred.resolve(resolve(value).promiseSend("when", _fulfilled, _rejected));
1452 }
1453 }, function(exception) {
1454 if (!l) {
1455 /** @type {boolean} */
1456 l = true;
1457 deferred.resolve(_rejected(exception));
1458 }
1459 });
1460 }), deferred.promise;
1461 }
1462 /**
1463 * @param {string} op
1464 * @return {?}
1465 */
1466 function Method(op) {
1467 return function(err) {
1468 /** @type {Array.<?>} */
1469 var args = __slice.call(arguments, 1);
1470 return send.apply(void 0, [err, op].concat(args));
1471 };
1472 }
1473 /**
1474 * @param {undefined} object
1475 * @param {?} context
1476 * @return {?}
1477 */
1478 function send(object, context) {
1479 var deferred = defer();
1480 /** @type {Array.<?>} */
1481 var otherArgs = __slice.call(arguments, 2);
1482 return object = resolve(object), nextTick(function() {
1483 object.promiseSend.apply(object, [context, deferred.resolve].concat(otherArgs));
1484 }), deferred.promise;
1485 }
1486 /**
1487 * @param {?} promises
1488 * @return {?}
1489 */
1490 function all(promises) {
1491 return when(promises, function(value) {
1492 var len = value.length;
1493 if (0 === len) {
1494 return resolve(values);
1495 }
1496 var deferred = defer();
1497 return jQuery.call(value, function(dataAndEvents, promise, name) {
1498 when(promise, function(rhs) {
1499 value[name] = rhs;
1500 if (0 == --len) {
1501 deferred.resolve(value);
1502 }
1503 }).fail(deferred.reject);
1504 }, void 0), deferred.promise;
1505 });
1506 }
1507 /**
1508 * @param {?} file
1509 * @return {?}
1510 */
1511 function wrap(file) {
1512 return function() {
1513 var result = defer();
1514 return __slice.call(arguments), callback(file, this, result).fail(result.reject), result.promise;
1515 };
1516 }
1517 /**
1518 * @param {Function} callback
1519 * @return {?}
1520 */
1521 function load(callback) {
1522 if (arguments.length > 1) {
1523 /** @type {Array.<?>} */
1524 var args = Array.prototype.slice.call(arguments, 1);
1525 callback = callback.bind.apply(callback, args);
1526 }
1527 return function() {
1528 var result = defer();
1529 /** @type {Array.<?>} */
1530 var nodeArgs = __slice.call(arguments);
1531 return nodeArgs.push(result.node()), ok(callback, this, nodeArgs).fail(result.reject), result.promise;
1532 };
1533 }
1534 var exports = {};
1535 /**
1536 * @param {Object} object
1537 * @param {string} name
1538 * @param {Function} shim
1539 * @return {?}
1540 */
1541 var shim = function(object, name, shim) {
1542 return object[name] || (object[name] = shim), object[name];
1543 };
1544 var freeze = shim(Object, "freeze", identity);
1545 var create = shim(Object, "create", function(prototype) {
1546 /**
1547 * @return {undefined}
1548 */
1549 var Type = function() {
1550 };
1551 return Type.prototype = prototype, new Type;
1552 });
1553 var keys = shim(Object, "keys", function(dataAndEvents) {
1554 /** @type {Array} */
1555 var assigns = [];
1556 var vvar;
1557 for (vvar in dataAndEvents) {
1558 assigns.push(vvar);
1559 }
1560 return assigns;
1561 });
1562 /** @type {function (this:(Array.<T>|string|{length: number}), (function (?, T, number, Array.<T>): R|null), *=): R} */
1563 var jQuery = Array.prototype.reduce || function(callback, basis) {
1564 /** @type {number} */
1565 var index = 0;
1566 var length = this.length;
1567 if (1 == arguments.length) {
1568 for (;;) {
1569 if (index in this) {
1570 basis = this[index++];
1571 break;
1572 }
1573 if (++index >= length) {
1574 throw new TypeError;
1575 }
1576 }
1577 }
1578 for (;index < length;index++) {
1579 if (index in this) {
1580 basis = callback(basis, this[index], index);
1581 }
1582 }
1583 return basis;
1584 };
1585 /**
1586 * @param {Object} obj
1587 * @return {?}
1588 */
1589 var isString = function(obj) {
1590 return "[object StopIteration]" === Object.prototype.toString.call(obj);
1591 };
1592 /** @type {function (this:(Array.<T>|string|{length: number}), *=, *=): Array.<T>} */
1593 var __slice = Array.prototype.slice;
1594 /**
1595 * @param {number} value
1596 * @return {?}
1597 */
1598 var valueOf = function(value) {
1599 return void 0 === value || null === value ? value : value.valueOf();
1600 };
1601 /** @type {function (Function): undefined} */
1602 exports.nextTick = nextTick;
1603 /** @type {function (): ?} */
1604 exports.defer = defer;
1605 /**
1606 * @return {?}
1607 */
1608 defer.prototype.node = function() {
1609 var resolver = this;
1610 return function(reason, value) {
1611 if (reason) {
1612 resolver.reject(reason);
1613 } else {
1614 if (arguments.length > 2) {
1615 resolver.resolve(Array.prototype.slice.call(arguments, 1));
1616 } else {
1617 resolver.resolve(value);
1618 }
1619 }
1620 };
1621 };
1622 /** @type {function (undefined, Function, Function): ?} */
1623 exports.makePromise = Promise;
1624 /**
1625 * @param {Function} fulfilled
1626 * @param {Function} rejected
1627 * @return {?}
1628 */
1629 Promise.prototype.then = function(fulfilled, rejected) {
1630 return when(this, fulfilled, rejected);
1631 };
1632 jQuery.call(["when", "spread", "send", "get", "put", "del", "post", "invoke", "keys", "apply", "call", "all", "wait", "join", "fail", "fin", "timeout", "delay", "end"], function(dataAndEvents, name) {
1633 /**
1634 * @return {?}
1635 */
1636 Promise.prototype[name] = function() {
1637 return exports[name].apply(exports, [this].concat(__slice.call(arguments)));
1638 };
1639 }, void 0);
1640 /**
1641 * @return {?}
1642 */
1643 Promise.prototype.toSource = function() {
1644 return this.toString();
1645 };
1646 /**
1647 * @return {?}
1648 */
1649 Promise.prototype.toString = function() {
1650 return "[object Promise]";
1651 };
1652 freeze(Promise.prototype);
1653 /** @type {function (boolean): ?} */
1654 exports.isPromise = isPromise;
1655 /**
1656 * @param {number} object
1657 * @return {?}
1658 */
1659 exports.isResolved = function(object) {
1660 return!isPromise(valueOf(object));
1661 };
1662 /**
1663 * @param {number} object
1664 * @return {?}
1665 */
1666 exports.isFulfilled = function(object) {
1667 return!isPromise(valueOf(object)) && !isRejected(object);
1668 };
1669 /** @type {function (number): ?} */
1670 exports.isRejected = isRejected;
1671 /** @type {function (string): ?} */
1672 exports.reject = reject;
1673 var props = {};
1674 props.constructor = {};
1675 /** @type {function (string): ?} */
1676 props.constructor.value = reject;
1677 reject.prototype = create(Promise.prototype, props);
1678 /** @type {function (Object): ?} */
1679 exports.ref = resolve;
1680 /**
1681 * @param {number} object
1682 * @return {?}
1683 */
1684 exports.master = function(object) {
1685 var activeClassName = {};
1686 return activeClassName.isDef = function() {
1687 }, Promise(activeClassName, function(dataAndEvents) {
1688 /** @type {Array.<?>} */
1689 var args = __slice.call(arguments);
1690 return send.apply(void 0, [object].concat(args));
1691 }, function() {
1692 return valueOf(object);
1693 });
1694 };
1695 /** @type {function (?, Function, Function): ?} */
1696 exports.when = when;
1697 /**
1698 * @param {?} promise
1699 * @param {Function} fulfilled
1700 * @param {Function} rejected
1701 * @return {?}
1702 */
1703 exports.spread = function(promise, fulfilled, rejected) {
1704 return when(promise, function(array) {
1705 return fulfilled.apply(void 0, array);
1706 }, rejected);
1707 };
1708 /**
1709 * @param {Function} matcherFunction
1710 * @return {?}
1711 */
1712 exports.async = function(matcherFunction) {
1713 return function() {
1714 /**
1715 * @param {?} method
1716 * @param {?} resp
1717 * @return {?}
1718 */
1719 var next = function(method, resp) {
1720 var result;
1721 try {
1722 result = collection[method](resp);
1723 } catch (value) {
1724 return isString(value) ? value.value : reject(value);
1725 }
1726 return when(result, callback, errback);
1727 };
1728 var collection = matcherFunction.apply(this, arguments);
1729 var callback = next.bind(next, "send");
1730 var errback = next.bind(next, "throw");
1731 return callback();
1732 };
1733 };
1734 /** @type {function (string): ?} */
1735 exports.Method = Method;
1736 /** @type {function (undefined, ?): ?} */
1737 exports.send = send;
1738 exports.get = Method("get");
1739 exports.put = Method("put");
1740 exports.del = Method("del");
1741 var nodeProxyInvoke = exports.post = Method("post");
1742 /**
1743 * @param {?} thisValue
1744 * @param {?} method
1745 * @return {?}
1746 */
1747 exports.invoke = function(thisValue, method) {
1748 /** @type {Array.<?>} */
1749 var args = __slice.call(arguments, 2);
1750 return nodeProxyInvoke(thisValue, method, args);
1751 };
1752 var ok = exports.apply = Method("apply");
1753 /** @type {function (Object, Object): ?} */
1754 var callback = exports.call = function(callback, type) {
1755 /** @type {Array.<?>} */
1756 var expectedArgs = __slice.call(arguments, 2);
1757 return ok(callback, type, expectedArgs);
1758 };
1759 return exports.keys = Method("keys"), exports.all = all, exports.wait = function(handler) {
1760 return all(arguments).get(0);
1761 }, exports.join = function() {
1762 /** @type {Array.<?>} */
1763 var args = __slice.call(arguments);
1764 var rejection = args.pop();
1765 return all(args).spread(rejection);
1766 }, exports.fail = function(promise, rejected) {
1767 return when(promise, void 0, rejected);
1768 }, exports.fin = function(promise, callback) {
1769 return when(promise, function(dataAndEvents) {
1770 return when(callback(), function() {
1771 return dataAndEvents;
1772 });
1773 }, function(reason) {
1774 return when(callback(), function() {
1775 return reject(reason);
1776 });
1777 });
1778 }, exports.end = function(promise) {
1779 when(promise, void 0, function(dataAndEvents) {
1780 nextTick(function() {
1781 throw dataAndEvents;
1782 });
1783 });
1784 }, exports.timeout = function(promise, ms) {
1785 var deferred = defer();
1786 return when(promise, deferred.resolve, deferred.reject), setTimeout(function() {
1787 deferred.reject("Timed out");
1788 }, ms), deferred.promise;
1789 }, exports.delay = function(func, wait) {
1790 if (arguments.length < 2) {
1791 /** @type {Object} */
1792 wait = func;
1793 func = void 0;
1794 }
1795 var d = defer();
1796 return setTimeout(function() {
1797 d.resolve(func);
1798 }, wait), d.promise;
1799 }, exports.wrap = wrap, exports.wcall = function(f) {
1800 /** @type {Array.<?>} */
1801 var args = __slice.call(arguments, 1);
1802 return wrap(f).apply(void 0, args);
1803 }, exports.node = load, exports.ncall = function(callback, exports) {
1804 /** @type {Array.<?>} */
1805 var args = __slice.call(arguments, 2);
1806 return load(callback).apply(exports, args);
1807 }, exports;
1808 }(clone);
1809 /** @type {string} */
1810 var userAgent = window.navigator.userAgent;
1811 /** @type {(number|undefined)} */
1812 var wrap = (Number((userAgent.match(/Firefox\/([0-9]+\.[0-9]+)/) || [0, 0])[1]) || undefined, Number((userAgent.match(/Chrome\/([0-9]+\.[0-9]+)/) || [0, 0])[1]) || undefined, Number((userAgent.match(/Version\/([0-9]+\.[0-9]+)(?:\.[0-9]+)?\sSafari\//) || [0, 0])[1]) || undefined);
1813 /** @type {(number|undefined)} */
1814 var cb = Number((userAgent.match(/Opera\/.*\sVersion\/([0-9]+\.[0-9]+)|Opera\/([0-9]+\.[0-9]+)/) || []).slice(1).join("")) || undefined;
1815 /** @type {(number|undefined)} */
1816 var HTMLEvents = (Number(userAgent.match(/(iPad|iPhone|iPod)(?:\sSimulator)?;[\s\w;]*?CPU/) && (userAgent.match(/U; CPU i?OS ([0-9]+_[0-9]+)/) || ["", "1_0"])[1].replace("_", ".")) || undefined, Number((navigator.userAgent.match(/MSIE ([\w.]+)/) || [])[1]) || undefined);
1817 var _createElement = function() {
1818 /** @type {function (this:Document, string): Element} */
1819 var old = document.createElement;
1820 return function(x) {
1821 return isEmpty() ? old.apply(document, arguments) : old(x);
1822 };
1823 }();
1824 var promiseOrValue = function() {
1825 var invokeDfd = Q.defer();
1826 return "readyState" in document && ("complete" === document.readyState && invokeDfd.resolve({})), on(document, "readystatechange", function(isXML) {
1827 if ("readyState" in document) {
1828 if ("complete" === document.readyState) {
1829 invokeDfd.resolve(isXML);
1830 }
1831 }
1832 }, true), on(document, "DOMContentLoaded", function(isXML) {
1833 invokeDfd.resolve(isXML);
1834 }, true), invokeDfd.promise;
1835 }();
1836 var promise = function() {
1837 var deferred = Q.defer();
1838 return "complete" === document.readyState && promiseOrValue.then(deferred.resolve), on(window, "load", function(translation) {
1839 deferred.resolve(translation);
1840 }, true), deferred.promise;
1841 }();
1842 var Parser = function e(t, n, r) {
1843 /**
1844 * @param {string} o
1845 * @param {?} u
1846 * @return {?}
1847 */
1848 function s(o, u) {
1849 if (!n[o]) {
1850 if (!t[o]) {
1851 var a = "function" == typeof require && require;
1852 if (!u && a) {
1853 return a(o, true);
1854 }
1855 if (i) {
1856 return i(o, true);
1857 }
1858 throw new Error("Cannot find module '" + o + "'");
1859 }
1860 var module_ = n[o] = {
1861 exports : {}
1862 };
1863 t[o][0].call(module_.exports, function(bits) {
1864 var max = t[o][1][bits];
1865 return s(max || bits);
1866 }, module_, module_.exports, e, t, n, r);
1867 }
1868 return n[o].exports;
1869 }
1870 var i = "function" == typeof require && require;
1871 /** @type {number} */
1872 var o = 0;
1873 for (;o < r.length;o++) {
1874 s(r[o]);
1875 }
1876 return s;
1877 }({
1878 1 : [function(require, module, dataAndEvents) {
1879 /**
1880 * @param {Object} cbs
1881 * @param {Object} options
1882 * @return {undefined}
1883 */
1884 function Parser(cbs, options) {
1885 this._options = options || {};
1886 this._cbs = cbs || {};
1887 /** @type {string} */
1888 this._tagname = "";
1889 /** @type {string} */
1890 this._attribname = "";
1891 /** @type {string} */
1892 this._attribvalue = "";
1893 /** @type {null} */
1894 this._attribs = null;
1895 /** @type {Array} */
1896 this._stack = [];
1897 this._tokenizer = new Scanner(this, this._options);
1898 }
1899 /**
1900 * @param {Array} attributes
1901 * @param {string} name
1902 * @return {?}
1903 */
1904 function post(attributes, name) {
1905 /** @type {number} */
1906 var i = attributes.length - 1;
1907 for (;i >= 0;i--) {
1908 if (name === attributes[i]) {
1909 return i;
1910 }
1911 }
1912 return-1;
1913 }
1914 var Scanner = require("./Tokenizer.js");
1915 var input = {
1916 input : true,
1917 option : true,
1918 optgroup : true,
1919 select : true,
1920 button : true,
1921 datalist : true,
1922 textarea : true
1923 };
1924 var timeMap = {
1925 tr : {
1926 tr : true,
1927 th : true,
1928 td : true
1929 },
1930 th : {
1931 th : true
1932 },
1933 td : {
1934 thead : true,
1935 td : true
1936 },
1937 body : {
1938 head : true,
1939 link : true,
1940 script : true
1941 },
1942 li : {
1943 li : true
1944 },
1945 p : {
1946 p : true
1947 },
1948 select : input,
1949 input : input,
1950 output : input,
1951 button : input,
1952 datalist : input,
1953 textarea : input,
1954 option : {
1955 option : true
1956 },
1957 optgroup : {
1958 optgroup : true
1959 }
1960 };
1961 var voidElements = {
1962 __proto__ : null,
1963 area : true,
1964 base : true,
1965 basefont : true,
1966 br : true,
1967 col : true,
1968 command : true,
1969 embed : true,
1970 frame : true,
1971 hr : true,
1972 img : true,
1973 input : true,
1974 isindex : true,
1975 keygen : true,
1976 link : true,
1977 meta : true,
1978 param : true,
1979 source : true,
1980 track : true,
1981 wbr : true,
1982 path : true,
1983 circle : true,
1984 ellipse : true,
1985 line : true,
1986 rect : true,
1987 use : true
1988 };
1989 /**
1990 * @param {string} data
1991 * @return {undefined}
1992 */
1993 Parser.prototype.ontext = function(data) {
1994 if (this._cbs.ontext) {
1995 this._cbs.ontext(data);
1996 }
1997 };
1998 /**
1999 * @param {string} name
2000 * @return {undefined}
2001 */
2002 Parser.prototype.onopentagname = function(name) {
2003 if (this._tagname = name, !this._options.xmlMode && name in timeMap) {
2004 var el;
2005 for (;(el = this._stack[this._stack.length - 1]) in timeMap[name];this.onclosetag(el)) {
2006 }
2007 }
2008 if (!(!this._options.xmlMode && name in voidElements)) {
2009 this._stack.push(name);
2010 }
2011 if (this._cbs.onopentagname) {
2012 this._cbs.onopentagname(name);
2013 }
2014 if (this._cbs.onopentag) {
2015 this._attribs = {};
2016 }
2017 };
2018 /**
2019 * @return {undefined}
2020 */
2021 Parser.prototype.onopentagend = function() {
2022 if (this._attribs) {
2023 if (this._cbs.onopentag) {
2024 this._cbs.onopentag(this._tagname, this._attribs);
2025 }
2026 /** @type {null} */
2027 this._attribs = null;
2028 }
2029 if (!this._options.xmlMode) {
2030 if (this._cbs.onclosetag) {
2031 if (this._tagname in voidElements) {
2032 this._cbs.onclosetag(this._tagname);
2033 }
2034 }
2035 }
2036 if (!this._options.xmlMode) {
2037 if ("script" === this._tagname) {
2038 this._tokenizer.consumeScriptData();
2039 } else {
2040 if ("style" === this._tagname) {
2041 this._tokenizer.consumeRCData("style");
2042 }
2043 }
2044 }
2045 /** @type {string} */
2046 this._tagname = "";
2047 };
2048 /**
2049 * @param {string} name
2050 * @return {undefined}
2051 */
2052 Parser.prototype.onclosetag = function(name) {
2053 if (!this._stack.length || name in voidElements && !this._options.xmlMode) {
2054 if (!this._options.xmlMode) {
2055 if (!("br" !== name && "p" !== name)) {
2056 this.onopentagname(name);
2057 this._closeCurrentTag();
2058 }
2059 }
2060 } else {
2061 var pos = post(this._stack, name);
2062 if (-1 !== pos) {
2063 if (this._cbs.onclosetag) {
2064 /** @type {number} */
2065 pos = this._stack.length - pos;
2066 for (;pos--;) {
2067 this._cbs.onclosetag(this._stack.pop());
2068 }
2069 } else {
2070 this._stack.length = pos;
2071 }
2072 } else {
2073 if (!("p" !== name)) {
2074 if (!this._options.xmlMode) {
2075 this.onopentagname(name);
2076 this._closeCurrentTag();
2077 }
2078 }
2079 }
2080 }
2081 };
2082 /**
2083 * @return {undefined}
2084 */
2085 Parser.prototype.onselfclosingtag = function() {
2086 if (this._options.xmlMode || this._options.recognizeSelfClosing) {
2087 this._closeCurrentTag();
2088 } else {
2089 this.onopentagend();
2090 }
2091 };
2092 /**
2093 * @return {undefined}
2094 */
2095 Parser.prototype._closeCurrentTag = function() {
2096 var name = this._tagname;
2097 this.onopentagend();
2098 if (this._stack[this._stack.length - 1] === name) {
2099 if (this._cbs.onclosetag) {
2100 this._cbs.onclosetag(name);
2101 }
2102 this._stack.pop();
2103 }
2104 };
2105 /**
2106 * @param {?} name
2107 * @param {string} value
2108 * @return {undefined}
2109 */
2110 Parser.prototype.onattribute = function(name, value) {
2111 if (this._cbs.onattribute) {
2112 this._cbs.onattribute(name, value);
2113 }
2114 if (this._attribs) {
2115 if (!Object.prototype.hasOwnProperty.call(this._attribs, name)) {
2116 /** @type {string} */
2117 this._attribs[name] = value;
2118 }
2119 }
2120 };
2121 /**
2122 * @param {string} value
2123 * @return {undefined}
2124 */
2125 Parser.prototype.oncomment = function(value) {
2126 if (this._cbs.oncomment) {
2127 this._cbs.oncomment(value);
2128 }
2129 };
2130 /**
2131 * @return {undefined}
2132 */
2133 Parser.prototype.oncommentend = function() {
2134 if (this._cbs.oncommentend) {
2135 this._cbs.oncommentend();
2136 }
2137 };
2138 /**
2139 * @param {string} data
2140 * @return {undefined}
2141 */
2142 Parser.prototype.oncdata = function(data) {
2143 if (this._options.xmlMode || this._options.recognizeCDATA) {
2144 if (this._cbs.oncdatastart) {
2145 this._cbs.oncdatastart();
2146 }
2147 if (this._cbs.ontext) {
2148 this._cbs.ontext(data);
2149 }
2150 if (this._cbs.oncdataend) {
2151 this._cbs.oncdataend();
2152 }
2153 } else {
2154 if (this._cbs.oncomment) {
2155 this.oncomment("[CDATA[" + data + "]]");
2156 }
2157 if (this._cbs.oncommentend) {
2158 this._cbs.oncommentend();
2159 }
2160 }
2161 };
2162 /**
2163 * @param {?} recurring
2164 * @param {Function} crossScope
2165 * @param {Function} opt_gotoEnd
2166 * @param {boolean} opt_isDefault
2167 * @return {undefined}
2168 */
2169 Parser.prototype.ondoctype = function(recurring, crossScope, opt_gotoEnd, opt_isDefault) {
2170 if (this._cbs.ondoctype) {
2171 this._cbs.ondoctype(recurring, crossScope, opt_gotoEnd, opt_isDefault);
2172 }
2173 };
2174 /**
2175 * @param {Error} error
2176 * @return {undefined}
2177 */
2178 Parser.prototype.onerror = function(error) {
2179 if (this._cbs.onerror) {
2180 this._cbs.onerror(error);
2181 }
2182 };
2183 /**
2184 * @return {undefined}
2185 */
2186 Parser.prototype.onend = function() {
2187 if (this._cbs.onclosetag) {
2188 var i = this._stack.length;
2189 for (;i > 0;this._cbs.onclosetag(this._stack[--i])) {
2190 }
2191 }
2192 if (this._cbs.onend) {
2193 this._cbs.onend();
2194 }
2195 };
2196 /**
2197 * @return {undefined}
2198 */
2199 Parser.prototype.reset = function() {
2200 if (this._cbs.onreset) {
2201 this._cbs.onreset();
2202 }
2203 this._tokenizer.reset();
2204 /** @type {string} */
2205 this._tagname = "";
2206 /** @type {string} */
2207 this._attribname = "";
2208 /** @type {null} */
2209 this._attribs = null;
2210 /** @type {Array} */
2211 this._stack = [];
2212 };
2213 /**
2214 * @param {string} data
2215 * @return {undefined}
2216 */
2217 Parser.prototype.parseComplete = function(data) {
2218 this.reset();
2219 this.end(data);
2220 };
2221 /**
2222 * @param {string} data
2223 * @return {undefined}
2224 */
2225 Parser.prototype.write = function(data) {
2226 this._tokenizer.write(data);
2227 };
2228 /**
2229 * @param {string} chunk
2230 * @return {undefined}
2231 */
2232 Parser.prototype.end = function(chunk) {
2233 this._tokenizer.end(chunk);
2234 };
2235 /**
2236 * @return {undefined}
2237 */
2238 Parser.prototype.pause = function() {
2239 this._tokenizer.pause();
2240 };
2241 /**
2242 * @return {undefined}
2243 */
2244 Parser.prototype.resume = function() {
2245 this._tokenizer.resume();
2246 };
2247 /** @type {function (string): undefined} */
2248 Parser.prototype.parseChunk = Parser.prototype.write;
2249 /** @type {function (string): undefined} */
2250 Parser.prototype.done = Parser.prototype.end;
2251 /** @type {function (Object, Object): undefined} */
2252 module.exports = Parser;
2253 }, {
2254 "./Tokenizer.js" : 2
2255 }],
2256 2 : [function(require, context, dataAndEvents) {
2257 /**
2258 * @param {string} putativeSpy
2259 * @return {?}
2260 */
2261 function encodeUriQuery(putativeSpy) {
2262 return " " === putativeSpy || ("\n" === putativeSpy || ("\t" === putativeSpy || ("\f" === putativeSpy || "\r" === putativeSpy)));
2263 }
2264 /**
2265 * @param {string} putativeSpy
2266 * @return {?}
2267 */
2268 function lookupIterator(putativeSpy) {
2269 return String.fromCharCode(putativeSpy.charCodeAt(0) + 32);
2270 }
2271 /**
2272 * @param {string} val
2273 * @return {?}
2274 */
2275 function ondata(val) {
2276 return val >= "0" && val <= "9";
2277 }
2278 /**
2279 * @param {string} putativeSpy
2280 * @return {?}
2281 */
2282 function isClassOf(putativeSpy) {
2283 return putativeSpy >= "A" && putativeSpy <= "Z";
2284 }
2285 /**
2286 * @param {string} s
2287 * @return {?}
2288 */
2289 function hasKey(s) {
2290 return s >= "a" && s <= "z";
2291 }
2292 /**
2293 * @param {string} value
2294 * @return {?}
2295 */
2296 function isArguments(value) {
2297 return hasKey(value) || isClassOf(value);
2298 }
2299 /**
2300 * @param {string} key
2301 * @return {?}
2302 */
2303 function has(key) {
2304 return key === m || (key === length || key === name);
2305 }
2306 /**
2307 * @param {?} _
2308 * @param {string} execResult
2309 * @param {string} state
2310 * @return {?}
2311 */
2312 function parse(_, execResult, state) {
2313 return function(data) {
2314 if (data === _) {
2315 /** @type {string} */
2316 this._state = execResult;
2317 } else {
2318 /** @type {string} */
2319 this._state = state;
2320 this[state](data);
2321 }
2322 };
2323 }
2324 /**
2325 * @param {Object} err
2326 * @param {Object} options
2327 * @return {undefined}
2328 */
2329 function self(err, options) {
2330 /** @type {string} */
2331 this._state = state;
2332 /** @type {string} */
2333 this._buffer = "";
2334 /** @type {number} */
2335 this._sectionStart = 0;
2336 /** @type {number} */
2337 this._index = 0;
2338 /** @type {string} */
2339 this._baseState = state;
2340 /** @type {string} */
2341 this._nextState = state;
2342 /** @type {string} */
2343 this._sequence = "";
2344 /** @type {number} */
2345 this._sequenceIndex = 0;
2346 /** @type {Object} */
2347 this._cbs = err;
2348 /** @type {boolean} */
2349 this._running = true;
2350 /** @type {boolean} */
2351 this._ended = false;
2352 /** @type {boolean} */
2353 this._xmlMode = !(!options || !options.xmlMode);
2354 /** @type {boolean} */
2355 this._decodeEntities = !(!options || !options.decodeEntities);
2356 /** @type {boolean} */
2357 this._lowerCaseTagNames = options && "lowerCaseTags" in options ? !!options.lowerCaseTags : !this._xmlMode;
2358 /** @type {boolean} */
2359 this._lowerCaseAttributeNames = options && "lowerCaseAttributeNames" in options ? !!options.lowerCaseAttributeNames : !this._xmlMode;
2360 /** @type {boolean} */
2361 this._debug = !(!options || !options.debug);
2362 /** @type {null} */
2363 this._nameBuffer = null;
2364 /** @type {null} */
2365 this._valueBuffer = null;
2366 /** @type {null} */
2367 this._systemBuffer = null;
2368 }
2369 /**
2370 * @param {(number|string)} failing_message
2371 * @return {?}
2372 */
2373 function report(failing_message) {
2374 return function(dataAndEvents) {
2375 if ("<" === dataAndEvents) {
2376 /** @type {(number|string)} */
2377 this._state = failing_message;
2378 if (this._index > this._sectionStart) {
2379 this._cbs.ontext(this._getSection());
2380 }
2381 this._sectionStart = this._index;
2382 } else {
2383 if ("\x00" === dataAndEvents) {
2384 if (this._index > this._sectionStart) {
2385 this._cbs.ontext(this._getSection());
2386 }
2387 this._cbs.ontext(rawData);
2388 this._sectionStart = this._index + 1;
2389 }
2390 }
2391 };
2392 }
2393 /**
2394 * @param {string} state
2395 * @param {?} json
2396 * @return {?}
2397 */
2398 function dispatch(state, json) {
2399 return function(inputStr) {
2400 if ("/" === inputStr) {
2401 /** @type {string} */
2402 this._state = partName;
2403 /** @type {number} */
2404 this._sequenceIndex = 0;
2405 this._nextState = json;
2406 /** @type {string} */
2407 this._baseState = state;
2408 } else {
2409 /** @type {string} */
2410 this._state = state;
2411 this[this._baseState](inputStr);
2412 }
2413 };
2414 }
2415 /**
2416 * @param {string} y
2417 * @return {?}
2418 */
2419 function fn(y) {
2420 return function(x) {
2421 if (x === y) {
2422 /** @type {string} */
2423 this._state = cur;
2424 this._cbs.onattribute(this._nameBuffer, this._valueBuffer + this._getEndingSection());
2425 /** @type {null} */
2426 this._nameBuffer = this._valueBuffer = null;
2427 } else {
2428 if (this._decodeEntities && "&" === x) {
2429 this._valueBuffer += this._getSection();
2430 this._baseState = this._state;
2431 /** @type {string} */
2432 this._state = _name;
2433 this._sectionStart = this._index;
2434 } else {
2435 if ("\x00" === x) {
2436 this._valueBuffer += this._getPartialSection() + rawData;
2437 }
2438 }
2439 }
2440 };
2441 }
2442 /**
2443 * @param {string} id
2444 * @return {?}
2445 */
2446 function getById(id) {
2447 return function(pluginId) {
2448 if (pluginId === id) {
2449 /** @type {string} */
2450 this._state = prev;
2451 this._valueBuffer += this._getEndingSection();
2452 } else {
2453 if (">" === pluginId) {
2454 /** @type {string} */
2455 this._state = state;
2456 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer + this._getPartialSection(), null, false);
2457 /** @type {null} */
2458 this._nameBuffer = this._valueBuffer = null;
2459 } else {
2460 if ("\x00" === pluginId) {
2461 this._valueBuffer += this._getPartialSection() + rawData;
2462 }
2463 }
2464 }
2465 };
2466 }
2467 /**
2468 * @param {string} dataAndEvents
2469 * @return {?}
2470 */
2471 function clone(dataAndEvents) {
2472 return function(deepDataAndEvents) {
2473 if (deepDataAndEvents === dataAndEvents) {
2474 /** @type {string} */
2475 this._state = next;
2476 this._systemBuffer += this._getEndingSection();
2477 } else {
2478 if (">" === deepDataAndEvents) {
2479 /** @type {string} */
2480 this._state = state;
2481 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer, this._systemBuffer + this._getPartialSection(), false);
2482 /** @type {null} */
2483 this._nameBuffer = this._valueBuffer = this._systemBuffer = null;
2484 } else {
2485 if ("\x00" === deepDataAndEvents) {
2486 this._systemBuffer += this._getPartialSection() + rawData;
2487 }
2488 }
2489 }
2490 };
2491 }
2492 /** @type {function (Object, Object): undefined} */
2493 context.exports = self;
2494 var process = require("entities/lib/decode_codepoint.js");
2495 var nodes = require("entities/maps/entities.json");
2496 var client = require("entities/maps/legacy.json");
2497 var Block = require("entities/maps/xml.json");
2498 /** @type {string} */
2499 var state = "DATA";
2500 /** @type {string} */
2501 var cur = "BEFORE_ATTRIBUTE_NAME";
2502 /** @type {string} */
2503 var name = "ATTRIBUTE_VALUE_DQ";
2504 /** @type {string} */
2505 var length = "ATTRIBUTE_VALUE_SQ";
2506 /** @type {string} */
2507 var m = "ATTRIBUTE_VALUE_NQ";
2508 /** @type {string} */
2509 var value = "COMMENT";
2510 /** @type {string} */
2511 var _name = "BEFORE_ENTITY";
2512 /** @type {string} */
2513 var prev = "DT_BETWEEN_PUB_SYS";
2514 /** @type {string} */
2515 var next = "AFTER_DT_SYSTEM_IDENT";
2516 /** @type {string} */
2517 var partName = "SEQUENCE";
2518 /** @type {string} */
2519 var rawData = "\u00ef\u00bf\u00bd";
2520 var result = self.prototype;
2521 /**
2522 * @param {string} dataAndEvents
2523 * @param {(number|string)} deepDataAndEvents
2524 * @param {string} ignoreMethodDoesntExist
2525 * @return {undefined}
2526 */
2527 self.prototype._consumeSequence = function(dataAndEvents, deepDataAndEvents, ignoreMethodDoesntExist) {
2528 /** @type {string} */
2529 this._sequence = dataAndEvents;
2530 /** @type {(number|string)} */
2531 this._nextState = deepDataAndEvents;
2532 /** @type {string} */
2533 this._baseState = ignoreMethodDoesntExist;
2534 /** @type {string} */
2535 this._state = partName;
2536 /** @type {number} */
2537 this._sequenceIndex = 0;
2538 };
2539 /**
2540 * @param {string} value
2541 * @return {undefined}
2542 */
2543 result[partName] = function(value) {
2544 var object = this._sequence.charAt(this._sequenceIndex);
2545 if (value === object || lookupIterator(value) === object) {
2546 this._sequenceIndex += 1;
2547 if (this._sequenceIndex === this._sequence.length) {
2548 this._state = this._nextState;
2549 }
2550 } else {
2551 this._state = this._baseState;
2552 this[this._baseState](value);
2553 }
2554 };
2555 /**
2556 * @param {string} dataAndEvents
2557 * @return {undefined}
2558 */
2559 result[state] = function(dataAndEvents) {
2560 if (this._decodeEntities && "&" === dataAndEvents) {
2561 this._baseState = this._state;
2562 /** @type {string} */
2563 this._state = _name;
2564 if (this._index > this._sectionStart) {
2565 this._cbs.ontext(this._getSection());
2566 }
2567 this._sectionStart = this._index;
2568 } else {
2569 if ("<" === dataAndEvents) {
2570 /** @type {string} */
2571 this._state = "TAG_OPEN";
2572 if (this._index > this._sectionStart) {
2573 this._cbs.ontext(this._getSection());
2574 }
2575 this._sectionStart = this._index;
2576 }
2577 }
2578 };
2579 /**
2580 * @param {string} dataAndEvents
2581 * @return {undefined}
2582 */
2583 result.RCDATA_STATE = function(dataAndEvents) {
2584 if (this._decodeEntities && "&" === dataAndEvents) {
2585 this._baseState = this._state;
2586 /** @type {string} */
2587 this._state = _name;
2588 if (this._index > this._sectionStart) {
2589 this._cbs.ontext(this._getSection());
2590 }
2591 this._sectionStart = this._index;
2592 } else {
2593 if ("<" === dataAndEvents) {
2594 /** @type {string} */
2595 this._state = "RCDATA_LT_SIGN_STATE";
2596 if (this._index > this._sectionStart) {
2597 this._cbs.ontext(this._getSection());
2598 }
2599 this._sectionStart = this._index;
2600 } else {
2601 if ("\x00" === dataAndEvents) {
2602 if (this._index > this._sectionStart) {
2603 this._cbs.ontext(this._getSection());
2604 }
2605 this._cbs.ontext(rawData);
2606 this._sectionStart = this._index + 1;
2607 }
2608 }
2609 }
2610 };
2611 result.RAWTEXT_STATE = report("RAWTEXT_LT_SIGN_STATE");
2612 result.SCRIPT_DATA_STATE = report("SCRIPT_DATA_LT_SIGN_STATE");
2613 /**
2614 * @param {string} dataAndEvents
2615 * @return {undefined}
2616 */
2617 result.PLAINTEXT_STATE = function(dataAndEvents) {
2618 if ("\x00" === dataAndEvents) {
2619 if (this._index > this._sectionStart) {
2620 this._cbs.ontext(this._getSection());
2621 }
2622 this._cbs.ontext(rawData);
2623 this._sectionStart = this._index + 1;
2624 }
2625 };
2626 /**
2627 * @param {string} value
2628 * @return {undefined}
2629 */
2630 result.TAG_OPEN = function(value) {
2631 if ("!" === value) {
2632 /** @type {string} */
2633 this._state = "MARKUP_DECLARATION_OPEN";
2634 this._sectionStart = this._index + 1;
2635 } else {
2636 if ("/" === value) {
2637 /** @type {string} */
2638 this._state = "END_TAG_OPEN";
2639 } else {
2640 if (this._lowerCaseTagNames && isClassOf(value)) {
2641 /** @type {string} */
2642 this._state = "TAG_NAME";
2643 this._nameBuffer = lookupIterator(value);
2644 this._sectionStart = this._index + 1;
2645 } else {
2646 if (isArguments(value)) {
2647 /** @type {string} */
2648 this._state = "TAG_NAME";
2649 /** @type {string} */
2650 this._nameBuffer = "";
2651 this._sectionStart = this._index;
2652 } else {
2653 if ("?" === value) {
2654 /** @type {string} */
2655 this._state = "BOGUS_COMMENT";
2656 this._sectionStart = this._index;
2657 } else {
2658 /** @type {string} */
2659 this._state = state;
2660 this[state](value);
2661 }
2662 }
2663 }
2664 }
2665 }
2666 };
2667 /**
2668 * @param {string} value
2669 * @return {undefined}
2670 */
2671 result.END_TAG_OPEN = function(value) {
2672 if (this._lowerCaseTagNames && isClassOf(value)) {
2673 /** @type {string} */
2674 this._state = "IN_CLOSING_TAG_NAME";
2675 this._nameBuffer = lookupIterator(value);
2676 this._sectionStart = this._index + 1;
2677 } else {
2678 if (isArguments(value)) {
2679 /** @type {string} */
2680 this._state = "IN_CLOSING_TAG_NAME";
2681 /** @type {string} */
2682 this._nameBuffer = "";
2683 this._sectionStart = this._index;
2684 } else {
2685 if (">" === value) {
2686 /** @type {string} */
2687 this._state = state;
2688 this._sectionStart = this._index + 1;
2689 } else {
2690 /** @type {string} */
2691 this._state = "BOGUS_COMMENT";
2692 this._sectionStart = this._index;
2693 this.BOGUS_COMMENT(value);
2694 }
2695 }
2696 }
2697 };
2698 /**
2699 * @param {string} value
2700 * @return {undefined}
2701 */
2702 result.TAG_NAME = function(value) {
2703 if (encodeUriQuery(value)) {
2704 /** @type {string} */
2705 this._state = cur;
2706 this._cbs.onopentagname(this._nameBuffer + this._getEndingSection());
2707 } else {
2708 if ("/" === value) {
2709 /** @type {string} */
2710 this._state = "SELF_CLOSING_START_TAG";
2711 this._cbs.onopentagname(this._nameBuffer + this._getEndingSection());
2712 } else {
2713 if (">" === value) {
2714 /** @type {string} */
2715 this._state = state;
2716 this._cbs.onopentagname(this._nameBuffer + this._getPartialSection());
2717 this._cbs.onopentagend();
2718 } else {
2719 if ("\x00" === value) {
2720 this._nameBuffer += this._getPartialSection() + rawData;
2721 } else {
2722 if (this._lowerCaseTagNames) {
2723 if (isClassOf(value)) {
2724 this._nameBuffer += this._getPartialSection() + lookupIterator(value);
2725 }
2726 }
2727 }
2728 }
2729 }
2730 }
2731 };
2732 /**
2733 * @param {string} value
2734 * @return {undefined}
2735 */
2736 result.END_TAG_NAME_STATE = function(value) {
2737 if (encodeUriQuery(value) || "/" === value) {
2738 /** @type {string} */
2739 this._state = "AFTER_CLOSING_TAG_NAME";
2740 this._nameBuffer = this._sequence;
2741 } else {
2742 if (">" === value) {
2743 /** @type {string} */
2744 this._state = state;
2745 this._cbs.onclosetag(this._sequence);
2746 this._sectionStart = this._index + 1;
2747 } else {
2748 this._state = this._baseState;
2749 this[this._baseState](value);
2750 }
2751 }
2752 };
2753 result.RCDATA_LT_SIGN_STATE = dispatch("RCDATA_STATE", "END_TAG_NAME_STATE");
2754 result.RAWTEXT_LT_SIGN_STATE = dispatch("RAWTEXT_STATE", "END_TAG_NAME_STATE");
2755 /**
2756 * @param {string} inputStr
2757 * @return {undefined}
2758 */
2759 result.SCRIPT_DATA_LT_SIGN_STATE = function(inputStr) {
2760 if ("/" === inputStr) {
2761 /** @type {string} */
2762 this._state = partName;
2763 /** @type {number} */
2764 this._sequenceIndex = 0;
2765 /** @type {string} */
2766 this._nextState = "END_TAG_NAME_STATE";
2767 /** @type {string} */
2768 this._baseState = "SCRIPT_DATA_STATE";
2769 } else {
2770 if ("!" === inputStr) {
2771 /** @type {string} */
2772 this._state = "SCRIPT_DATA_ESCAPE_START_STATE";
2773 } else {
2774 /** @type {string} */
2775 this._state = "SCRIPT_DATA_STATE";
2776 this.SCRIPT_DATA_STATE(inputStr);
2777 }
2778 }
2779 };
2780 result.SCRIPT_DATA_ESCAPE_START_STATE = parse("-", "SCRIPT_DATA_ESCAPE_START_DASH_STATE", "SCRIPT_DATA_STATE");
2781 result.SCRIPT_DATA_ESCAPE_START_DASH_STATE = parse("-", "SCRIPT_DATA_ESCAPED_DASH_DASH_STATE", "SCRIPT_DATA_STATE");
2782 /**
2783 * @param {string} value
2784 * @return {undefined}
2785 */
2786 result.SCRIPT_DATA_ESCAPED_STATE = function(value) {
2787 if ("<" === value) {
2788 /** @type {string} */
2789 this._state = "SCRIPT_DATA_ESCAPED_LT_SIGN_STATE";
2790 } else {
2791 if ("-" === value) {
2792 /** @type {string} */
2793 this._state = "SCRIPT_DATA_ESCAPED_DASH_STATE";
2794 } else {
2795 if ("\x00" === value) {
2796 this._cbs.ontext(this._getPartialSection() + rawData);
2797 }
2798 }
2799 }
2800 };
2801 result.SCRIPT_DATA_ESCAPED_DASH_STATE = parse("-", "SCRIPT_DATA_ESCAPED_DASH_DASH_STATE", "SCRIPT_DATA_ESCAPED_STATE");
2802 /**
2803 * @param {string} isXML
2804 * @return {undefined}
2805 */
2806 result.SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = function(isXML) {
2807 if (">" === isXML) {
2808 /** @type {string} */
2809 this._state = "SCRIPT_DATA_STATE";
2810 } else {
2811 if ("-" !== isXML) {
2812 /** @type {string} */
2813 this._state = "SCRIPT_DATA_ESCAPED_STATE";
2814 this.SCRIPT_DATA_ESCAPED_STATE(isXML);
2815 }
2816 }
2817 };
2818 /**
2819 * @param {string} inputStr
2820 * @return {undefined}
2821 */
2822 result.SCRIPT_DATA_ESCAPED_LT_SIGN_STATE = function(inputStr) {
2823 if ("s" === inputStr || "S" === inputStr) {
2824 /** @type {string} */
2825 this._state = partName;
2826 /** @type {number} */
2827 this._sequenceIndex = 1;
2828 /** @type {string} */
2829 this._baseState = "SCRIPT_DATA_ESCAPED_STATE";
2830 /** @type {string} */
2831 this._nextState = "SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE";
2832 } else {
2833 if ("/" === inputStr) {
2834 this._cbs.ontext(this._getPartialSection());
2835 /** @type {string} */
2836 this._state = partName;
2837 /** @type {number} */
2838 this._sequenceIndex = 0;
2839 /** @type {string} */
2840 this._baseState = "SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE";
2841 /** @type {string} */
2842 this._nextState = "SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE";
2843 }
2844 }
2845 };
2846 /**
2847 * @param {string} haystack
2848 * @return {undefined}
2849 */
2850 result.SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = function(haystack) {
2851 /** @type {string} */
2852 this._state = "SCRIPT_DATA_ESCAPED_STATE";
2853 this._cbs.ontext("<-");
2854 this.SCRIPT_DATA_ESCAPED_STATE(haystack);
2855 };
2856 /**
2857 * @param {string} value
2858 * @return {undefined}
2859 */
2860 result.SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = function(value) {
2861 if (">" === value) {
2862 /** @type {string} */
2863 this._state = state;
2864 this._cbs.onclosetag(this._sequence);
2865 this._sectionStart = this._index + 1;
2866 } else {
2867 if (encodeUriQuery(value) || "/" === value) {
2868 this._nameBuffer = this._sequence;
2869 /** @type {string} */
2870 this._state = "AFTER_CLOSING_TAG_NAME";
2871 } else {
2872 this.SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE(value);
2873 }
2874 }
2875 };
2876 /**
2877 * @param {string} value
2878 * @return {undefined}
2879 */
2880 result.SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = function(value) {
2881 if (">" === value || ("/" === value || encodeUriQuery(value))) {
2882 /** @type {string} */
2883 this._state = "SCRIPT_DATA_DOUBLE_ESCAPED_STATE";
2884 } else {
2885 /** @type {string} */
2886 this._state = "SCRIPT_DATA_ESCAPED_STATE";
2887 this.SCRIPT_DATA_ESCAPED_STATE(value);
2888 }
2889 };
2890 /**
2891 * @param {string} value
2892 * @return {undefined}
2893 */
2894 result.SCRIPT_DATA_DOUBLE_ESCAPED_STATE = function(value) {
2895 if ("<" === value) {
2896 /** @type {string} */
2897 this._state = partName;
2898 /** @type {number} */
2899 this._sequenceIndex = 0;
2900 /** @type {string} */
2901 this._baseState = "SCRIPT_DATA_DOUBLE_ESCAPED_STATE";
2902 /** @type {string} */
2903 this._nextState = "SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE";
2904 } else {
2905 if ("-" === value) {
2906 /** @type {string} */
2907 this._state = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE";
2908 } else {
2909 if ("\x00" === value) {
2910 this._cbs.ontext(this._getPartialSection() + rawData);
2911 }
2912 }
2913 }
2914 };
2915 result.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = parse("-", "SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE", "SCRIPT_DATA_DOUBLE_ESCAPED_STATE");
2916 /**
2917 * @param {string} isXML
2918 * @return {undefined}
2919 */
2920 result.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = function(isXML) {
2921 if (">" === isXML) {
2922 /** @type {string} */
2923 this._state = "SCRIPT_DATA_STATE";
2924 } else {
2925 if ("-" !== isXML) {
2926 /** @type {string} */
2927 this._state = "SCRIPT_DATA_DOUBLE_ESCAPED_STATE";
2928 this.SCRIPT_DATA_DOUBLE_ESCAPED_STATE(isXML);
2929 }
2930 }
2931 };
2932 /**
2933 * @param {string} value
2934 * @return {undefined}
2935 */
2936 result.SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = function(value) {
2937 if (">" === value || ("/" === value || encodeUriQuery(value))) {
2938 /** @type {string} */
2939 this._state = "SCRIPT_DATA_ESCAPED_STATE";
2940 } else {
2941 /** @type {string} */
2942 this._state = "SCRIPT_DATA_DOUBLE_ESCAPED_STATE";
2943 this.SCRIPT_DATA_DOUBLE_ESCAPED_STATE(value);
2944 }
2945 };
2946 /**
2947 * @param {string} value
2948 * @return {undefined}
2949 */
2950 result[cur] = function(value) {
2951 if (">" === value) {
2952 /** @type {string} */
2953 this._state = state;
2954 this._cbs.onopentagend();
2955 this._sectionStart = this._index + 1;
2956 } else {
2957 if ("/" === value) {
2958 /** @type {string} */
2959 this._state = "SELF_CLOSING_START_TAG";
2960 } else {
2961 if (!encodeUriQuery(value)) {
2962 /** @type {string} */
2963 this._state = "ATTRIBUTE_NAME";
2964 if ("\x00" === value) {
2965 /** @type {string} */
2966 this._nameBuffer = rawData;
2967 this._sectionStart = this._index + 1;
2968 } else {
2969 if (this._lowerCaseAttributeNames && isClassOf(value)) {
2970 this._nameBuffer = lookupIterator(value);
2971 this._sectionStart = this._index + 1;
2972 } else {
2973 /** @type {string} */
2974 this._nameBuffer = "";
2975 this._sectionStart = this._index;
2976 }
2977 }
2978 }
2979 }
2980 }
2981 };
2982 /**
2983 * @param {string} value
2984 * @return {undefined}
2985 */
2986 result.ATTRIBUTE_NAME = function(value) {
2987 if ("=" === value || ("/" === value || (">" === value || encodeUriQuery(value)))) {
2988 /** @type {string} */
2989 this._state = "AFTER_ATTRIBUTE_NAME";
2990 this._nameBuffer += this._getEndingSection();
2991 this.AFTER_ATTRIBUTE_NAME(value);
2992 } else {
2993 if ("\x00" === value) {
2994 this._nameBuffer += this._getPartialSection() + rawData;
2995 } else {
2996 if (this._lowerCaseAttributeNames) {
2997 if (isClassOf(value)) {
2998 this._nameBuffer += this._getPartialSection() + lookupIterator(value);
2999 }
3000 }
3001 }
3002 }
3003 };
3004 /**
3005 * @param {string} value
3006 * @return {undefined}
3007 */
3008 result.AFTER_ATTRIBUTE_NAME = function(value) {
3009 if ("=" === value) {
3010 /** @type {string} */
3011 this._state = "BEFORE_ATTRIBUTE_VALUE";
3012 } else {
3013 if ("/" === value) {
3014 /** @type {string} */
3015 this._state = "SELF_CLOSING_START_TAG";
3016 this._cbs.onattribute(this._nameBuffer, "");
3017 /** @type {null} */
3018 this._nameBuffer = null;
3019 } else {
3020 if (">" === value) {
3021 /** @type {string} */
3022 this._state = state;
3023 this._cbs.onattribute(this._nameBuffer, "");
3024 /** @type {null} */
3025 this._nameBuffer = null;
3026 this._cbs.onopentagend();
3027 this._sectionStart = this._index + 1;
3028 } else {
3029 if (!encodeUriQuery(value)) {
3030 /** @type {string} */
3031 this._state = "ATTRIBUTE_NAME";
3032 this._cbs.onattribute(this._nameBuffer, "");
3033 if ("\x00" === value) {
3034 /** @type {string} */
3035 this._nameBuffer = rawData;
3036 this._sectionStart = this._index + 1;
3037 } else {
3038 if (this._lowerCaseAttributeNames && isClassOf(value)) {
3039 this._nameBuffer = lookupIterator(value);
3040 this._sectionStart = this._index + 1;
3041 } else {
3042 /** @type {string} */
3043 this._nameBuffer = "";
3044 this._sectionStart = this._index;
3045 }
3046 }
3047 }
3048 }
3049 }
3050 }
3051 };
3052 /**
3053 * @param {string} value
3054 * @return {undefined}
3055 */
3056 result.BEFORE_ATTRIBUTE_VALUE = function(value) {
3057 if ('"' === value) {
3058 /** @type {string} */
3059 this._state = name;
3060 /** @type {string} */
3061 this._valueBuffer = "";
3062 this._sectionStart = this._index + 1;
3063 } else {
3064 if ("'" === value) {
3065 /** @type {string} */
3066 this._state = length;
3067 /** @type {string} */
3068 this._valueBuffer = "";
3069 this._sectionStart = this._index + 1;
3070 } else {
3071 if (">" === value) {
3072 /** @type {string} */
3073 this._state = state;
3074 this._cbs.onattribute(this._nameBuffer, "");
3075 /** @type {null} */
3076 this._nameBuffer = null;
3077 this._cbs.onopentagend();
3078 this._sectionStart = this._index + 1;
3079 } else {
3080 if (!encodeUriQuery(value)) {
3081 /** @type {string} */
3082 this._state = m;
3083 /** @type {string} */
3084 this._valueBuffer = "";
3085 this._sectionStart = this._index;
3086 this[m](value);
3087 }
3088 }
3089 }
3090 }
3091 };
3092 result[name] = fn('"');
3093 result[length] = fn("'");
3094 /**
3095 * @param {string} value
3096 * @return {undefined}
3097 */
3098 result[m] = function(value) {
3099 if (encodeUriQuery(value)) {
3100 /** @type {string} */
3101 this._state = cur;
3102 this._cbs.onattribute(this._nameBuffer, this._valueBuffer + this._getEndingSection());
3103 /** @type {null} */
3104 this._nameBuffer = this._valueBuffer = null;
3105 } else {
3106 if (">" === value) {
3107 /** @type {string} */
3108 this._state = state;
3109 this._cbs.onattribute(this._nameBuffer, this._valueBuffer + this._getPartialSection());
3110 /** @type {null} */
3111 this._nameBuffer = this._valueBuffer = null;
3112 this._cbs.onopentagend();
3113 } else {
3114 if (this._decodeEntities && "&" === value) {
3115 this._valueBuffer += this._getSection();
3116 this._baseState = this._state;
3117 /** @type {string} */
3118 this._state = _name;
3119 this._sectionStart = this._index;
3120 } else {
3121 if ("\x00" === value) {
3122 this._valueBuffer += this._getPartialSection() + rawData;
3123 }
3124 }
3125 }
3126 }
3127 };
3128 /**
3129 * @param {string} checkSet
3130 * @return {undefined}
3131 */
3132 result.SELF_CLOSING_START_TAG = function(checkSet) {
3133 if (">" === checkSet) {
3134 /** @type {string} */
3135 this._state = state;
3136 this._cbs.onselfclosingtag();
3137 this._sectionStart = this._index + 1;
3138 } else {
3139 /** @type {string} */
3140 this._state = cur;
3141 this[cur](checkSet);
3142 }
3143 };
3144 /**
3145 * @param {string} ar
3146 * @return {undefined}
3147 */
3148 result.BOGUS_COMMENT = function(ar) {
3149 if (">" === ar) {
3150 /** @type {string} */
3151 this._state = state;
3152 this._cbs.oncomment(this._getPartialSection());
3153 this._cbs.oncommentend();
3154 } else {
3155 if ("\x00" === ar) {
3156 this._cbs.oncomment(this._getPartialSection() + rawData);
3157 this._sectionStart = this._index + 1;
3158 }
3159 }
3160 };
3161 /**
3162 * @param {string} c
3163 * @return {undefined}
3164 */
3165 result.MARKUP_DECLARATION_OPEN = function(c) {
3166 this._sectionStart = this._index;
3167 if ("-" === c) {
3168 /** @type {string} */
3169 this._state = "BEFORE_COMMENT";
3170 } else {
3171 if ("d" === c || "D" === c) {
3172 this._consumeSequence("octype", "BEFORE_DOCTYPE_NAME", "BOGUS_COMMENT");
3173 } else {
3174 if ("[" === c) {
3175 this._consumeSequence("CDATA", "BEFORE_CDATA", "BOGUS_COMMENT");
3176 } else {
3177 /** @type {string} */
3178 this._state = "BOGUS_COMMENT";
3179 this.BOGUS_COMMENT(c);
3180 }
3181 }
3182 }
3183 };
3184 /**
3185 * @param {string} apiPath
3186 * @return {undefined}
3187 */
3188 result.BEFORE_COMMENT = function(apiPath) {
3189 if ("-" === apiPath) {
3190 /** @type {string} */
3191 this._state = "COMMENT_START";
3192 this._sectionStart = this._index + 1;
3193 } else {
3194 /** @type {string} */
3195 this._state = "BOGUS_COMMENT";
3196 }
3197 };
3198 /**
3199 * @param {string} apiPath
3200 * @return {undefined}
3201 */
3202 result.COMMENT_START = function(apiPath) {
3203 if ("-" === apiPath) {
3204 /** @type {string} */
3205 this._state = "COMMENT_START_DASH";
3206 } else {
3207 if (">" === apiPath) {
3208 /** @type {string} */
3209 this._state = state;
3210 this._cbs.oncomment("");
3211 this._sectionStart = this._index + 1;
3212 } else {
3213 /** @type {string} */
3214 this._state = value;
3215 this[value](apiPath);
3216 }
3217 }
3218 };
3219 /**
3220 * @param {string} apiPath
3221 * @return {undefined}
3222 */
3223 result.COMMENT_START_DASH = function(apiPath) {
3224 if ("-" === apiPath) {
3225 /** @type {string} */
3226 this._state = "COMMENT_END";
3227 } else {
3228 if (">" === apiPath) {
3229 /** @type {string} */
3230 this._state = state;
3231 this._cbs.oncomment("");
3232 this._sectionStart = this._index + 1;
3233 } else {
3234 /** @type {string} */
3235 this._state = value;
3236 this[value](apiPath);
3237 }
3238 }
3239 };
3240 /**
3241 * @param {string} apiPath
3242 * @return {undefined}
3243 */
3244 result[value] = function(apiPath) {
3245 if ("-" === apiPath) {
3246 /** @type {string} */
3247 this._state = "COMMENT_END_DASH";
3248 } else {
3249 if ("\x00" === apiPath) {
3250 this._cbs.oncomment(this._getPartialSection() + rawData);
3251 this._sectionStart = this._index + 1;
3252 }
3253 }
3254 };
3255 result.COMMENT_END_DASH = parse("-", "COMMENT_END", value);
3256 /**
3257 * @param {string} scope
3258 * @return {undefined}
3259 */
3260 result.COMMENT_END = function(scope) {
3261 if (">" === scope) {
3262 /** @type {string} */
3263 this._state = state;
3264 this._cbs.oncomment(this._buffer.substring(this._sectionStart, this._index - 2));
3265 this._cbs.oncommentend();
3266 this._sectionStart = this._index + 1;
3267 } else {
3268 if ("!" === scope) {
3269 /** @type {string} */
3270 this._state = "COMMENT_END_BANG";
3271 } else {
3272 if ("-" !== scope) {
3273 /** @type {string} */
3274 this._state = value;
3275 this[value](scope);
3276 }
3277 }
3278 }
3279 };
3280 /**
3281 * @param {string} apiPath
3282 * @return {undefined}
3283 */
3284 result.COMMENT_END_BANG = function(apiPath) {
3285 if (">" === apiPath) {
3286 /** @type {string} */
3287 this._state = state;
3288 this._cbs.oncomment(this._buffer.substring(this._sectionStart, this._index - 3));
3289 this._cbs.oncommentend();
3290 this._sectionStart = this._index + 1;
3291 } else {
3292 if ("-" === apiPath) {
3293 /** @type {string} */
3294 this._state = "COMMENT_END_DASH";
3295 } else {
3296 /** @type {string} */
3297 this._state = value;
3298 this[value](apiPath);
3299 }
3300 }
3301 };
3302 /**
3303 * @param {string} value
3304 * @return {undefined}
3305 */
3306 result.IN_CLOSING_TAG_NAME = function(value) {
3307 if (encodeUriQuery(value) || "/" === value) {
3308 /** @type {string} */
3309 this._state = "AFTER_CLOSING_TAG_NAME";
3310 this._nameBuffer += this._getEndingSection();
3311 } else {
3312 if (">" === value) {
3313 /** @type {string} */
3314 this._state = state;
3315 this._cbs.onclosetag(this._nameBuffer + this._getPartialSection());
3316 } else {
3317 if ("\x00" === value) {
3318 this._nameBuffer += this._getPartialSection() + rawData;
3319 } else {
3320 if (this._lowerCaseTagNames) {
3321 if (isClassOf(value)) {
3322 this._nameBuffer += this._getPartialSection() + lookupIterator(value);
3323 }
3324 }
3325 }
3326 }
3327 }
3328 };
3329 /**
3330 * @param {string} dataAndEvents
3331 * @return {undefined}
3332 */
3333 result.AFTER_CLOSING_TAG_NAME = function(dataAndEvents) {
3334 if (">" === dataAndEvents) {
3335 /** @type {string} */
3336 this._state = state;
3337 this._cbs.onclosetag(this._nameBuffer);
3338 this._sectionStart = this._index + 1;
3339 }
3340 };
3341 /**
3342 * @param {string} value
3343 * @return {undefined}
3344 */
3345 result.BEFORE_DOCTYPE_NAME = function(value) {
3346 if (!encodeUriQuery(value)) {
3347 if (">" === value) {
3348 /** @type {string} */
3349 this._state = state;
3350 this._cbs.ondoctype(null, null, null, false);
3351 this._sectionStart = this._index + 1;
3352 } else {
3353 /** @type {string} */
3354 this._state = "DOCTYPE_NAME";
3355 if ("\x00" === value) {
3356 /** @type {string} */
3357 this._nameBuffer = rawData;
3358 this._sectionStart = this._index + 1;
3359 } else {
3360 if (this._lowerCaseTagNames && isClassOf(value)) {
3361 this._nameBuffer = lookupIterator(value);
3362 this._sectionStart = this._index + 1;
3363 } else {
3364 /** @type {string} */
3365 this._nameBuffer = "";
3366 this._sectionStart = this._index;
3367 }
3368 }
3369 }
3370 }
3371 };
3372 /**
3373 * @param {string} value
3374 * @return {undefined}
3375 */
3376 result.DOCTYPE_NAME = function(value) {
3377 if (encodeUriQuery(value)) {
3378 this._nameBuffer += this._getEndingSection();
3379 /** @type {string} */
3380 this._state = "AFTER_DOCTYPE_NAME";
3381 } else {
3382 if (">" === value) {
3383 /** @type {string} */
3384 this._state = state;
3385 this._cbs.ondoctype(this._nameBuffer + this._getPartialSection(), null, null, true);
3386 /** @type {null} */
3387 this._nameBuffer = null;
3388 } else {
3389 if ("\x00" === value) {
3390 this._nameBuffer += this._getPartialSection() + rawData;
3391 } else {
3392 if (this._lowerCaseTagNames) {
3393 if (isClassOf(value)) {
3394 this._nameBuffer += this._getPartialSection() + lookupIterator(value);
3395 }
3396 }
3397 }
3398 }
3399 }
3400 };
3401 /**
3402 * @param {string} object
3403 * @return {undefined}
3404 */
3405 result.AFTER_DOCTYPE_NAME = function(object) {
3406 if (">" === object) {
3407 /** @type {string} */
3408 this._state = state;
3409 this._cbs.ondoctype(this._nameBuffer, null, null, true);
3410 /** @type {null} */
3411 this._nameBuffer = null;
3412 this._sectionStart = this._index + 1;
3413 } else {
3414 if ("P" === object || "p" === object) {
3415 this._consumeSequence("ublic", "AFTER_DT_PUBLIC", "BOGUS_EVIL_DOCTYPE");
3416 } else {
3417 if ("S" === object || "s" === object) {
3418 this._consumeSequence("ystem", "AFTER_DT_SYSTEM", "BOGUS_EVIL_DOCTYPE");
3419 } else {
3420 /** @type {string} */
3421 this._state = "BOGUS_EVIL_DOCTYPE";
3422 }
3423 }
3424 }
3425 };
3426 /**
3427 * @param {string} value
3428 * @return {undefined}
3429 */
3430 result.AFTER_DT_PUBLIC = function(value) {
3431 if (!encodeUriQuery(value)) {
3432 if (">" === value) {
3433 /** @type {string} */
3434 this._state = state;
3435 this._cbs.ondoctype(this._nameBuffer, null, null, false);
3436 /** @type {null} */
3437 this._nameBuffer = null;
3438 this._sectionStart = this._index + 1;
3439 } else {
3440 if ('"' === value) {
3441 /** @type {string} */
3442 this._state = "DT_PUBLIC_DQ";
3443 /** @type {string} */
3444 this._valueBuffer = "";
3445 this._sectionStart = this._index + 1;
3446 } else {
3447 if ("'" === value) {
3448 /** @type {string} */
3449 this._state = "DT_PUBLIC_SQ";
3450 /** @type {string} */
3451 this._valueBuffer = "";
3452 this._sectionStart = this._index + 1;
3453 } else {
3454 /** @type {string} */
3455 this._state = "BOGUS_EVIL_DOCTYPE";
3456 }
3457 }
3458 }
3459 }
3460 };
3461 result.DT_PUBLIC_DQ = getById('"');
3462 result.DT_PUBLIC_SQ = getById("'");
3463 /**
3464 * @param {string} value
3465 * @return {undefined}
3466 */
3467 result[prev] = function(value) {
3468 if (!encodeUriQuery(value)) {
3469 if (">" === value) {
3470 /** @type {string} */
3471 this._state = state;
3472 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer, null, true);
3473 /** @type {null} */
3474 this._nameBuffer = this._valueBuffer = null;
3475 this._sectionStart = this._index + 1;
3476 } else {
3477 if ('"' === value) {
3478 /** @type {string} */
3479 this._state = "DT_SYSTEM_DQ";
3480 /** @type {string} */
3481 this._systemBuffer = "";
3482 this._sectionStart = this._index + 1;
3483 } else {
3484 if ("'" === value) {
3485 /** @type {string} */
3486 this._state = "DT_SYSTEM_SQ";
3487 /** @type {string} */
3488 this._systemBuffer = "";
3489 this._sectionStart = this._index + 1;
3490 } else {
3491 /** @type {string} */
3492 this._state = "BOGUS_EVIL_DOCTYPE";
3493 }
3494 }
3495 }
3496 }
3497 };
3498 /**
3499 * @param {string} value
3500 * @return {undefined}
3501 */
3502 result.AFTER_DT_SYSTEM = function(value) {
3503 if (!encodeUriQuery(value)) {
3504 if (">" === value) {
3505 /** @type {string} */
3506 this._state = state;
3507 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer, this._systemBuffer, false);
3508 /** @type {null} */
3509 this._nameBuffer = this._valueBuffer = this._systemBuffer = null;
3510 this._sectionStart = this._index + 1;
3511 } else {
3512 if ('"' === value) {
3513 /** @type {string} */
3514 this._state = "DT_SYSTEM_DQ";
3515 /** @type {string} */
3516 this._systemBuffer = "";
3517 this._sectionStart = this._index + 1;
3518 } else {
3519 if ("'" === value) {
3520 /** @type {string} */
3521 this._state = "DT_SYSTEM_SQ";
3522 /** @type {string} */
3523 this._systemBuffer = "";
3524 this._sectionStart = this._index + 1;
3525 } else {
3526 /** @type {string} */
3527 this._state = "BOGUS_EVIL_DOCTYPE";
3528 }
3529 }
3530 }
3531 }
3532 };
3533 result.DT_SYSTEM_DQ = clone('"');
3534 result.DT_SYSTEM_SQ = clone("'");
3535 /**
3536 * @param {string} value
3537 * @return {undefined}
3538 */
3539 result[next] = function(value) {
3540 if (!encodeUriQuery(value)) {
3541 /** @type {string} */
3542 this._state = "BOGUS_DOCTYPE";
3543 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer, this._systemBuffer, true);
3544 /** @type {null} */
3545 this._nameBuffer = this._valueBuffer = this._systemBuffer = null;
3546 this.BOGUS_DOCTYPE(value);
3547 }
3548 };
3549 /**
3550 * @param {string} isXML
3551 * @return {undefined}
3552 */
3553 result.BOGUS_EVIL_DOCTYPE = function(isXML) {
3554 /** @type {string} */
3555 this._state = "BOGUS_DOCTYPE";
3556 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer, this._systemBuffer, false);
3557 /** @type {null} */
3558 this._nameBuffer = this._valueBuffer = this._systemBuffer = null;
3559 this.BOGUS_DOCTYPE(isXML);
3560 };
3561 /**
3562 * @param {string} value
3563 * @return {undefined}
3564 */
3565 result.BOGUS_DOCTYPE = function(value) {
3566 if (">" === value) {
3567 /** @type {string} */
3568 this._state = state;
3569 this._sectionStart = this._index + 1;
3570 }
3571 };
3572 /**
3573 * @param {string} isXML
3574 * @return {undefined}
3575 */
3576 result.BEFORE_CDATA = function(isXML) {
3577 if ("[" === isXML) {
3578 /** @type {string} */
3579 this._state = "IN_CDATA";
3580 this._sectionStart = this._index + 1;
3581 } else {
3582 /** @type {string} */
3583 this._state = "BOGUS_COMMENT";
3584 this.BOGUS_DOCTYPE(isXML);
3585 }
3586 };
3587 result.IN_CDATA = function(b, state) {
3588 return function(a) {
3589 if (a === b) {
3590 /** @type {string} */
3591 this._state = state;
3592 }
3593 };
3594 }("]", "AFTER_CDATA_1");
3595 result.AFTER_CDATA_1 = parse("]", "AFTER_CDATA_2", "IN_CDATA");
3596 /**
3597 * @param {string} dataAndEvents
3598 * @return {undefined}
3599 */
3600 result.AFTER_CDATA_2 = function(dataAndEvents) {
3601 if (">" === dataAndEvents) {
3602 /** @type {string} */
3603 this._state = state;
3604 this._cbs.oncdata(this._buffer.substring(this._sectionStart, this._index - 2));
3605 this._sectionStart = this._index + 1;
3606 } else {
3607 if ("]" !== dataAndEvents) {
3608 /** @type {string} */
3609 this._state = "IN_CDATA";
3610 }
3611 }
3612 };
3613 /**
3614 * @param {Object} data
3615 * @return {undefined}
3616 */
3617 result[_name] = function(data) {
3618 if ("#" === data) {
3619 /** @type {string} */
3620 this._state = "BEFORE_NUMERIC_ENTITY";
3621 } else {
3622 /** @type {string} */
3623 this._state = "IN_NAMED_ENTITY";
3624 this.IN_NAMED_ENTITY(data);
3625 }
3626 };
3627 /**
3628 * @param {string} undef
3629 * @return {undefined}
3630 */
3631 result.BEFORE_NUMERIC_ENTITY = function(undef) {
3632 if ("x" === undef || "X" === undef) {
3633 /** @type {string} */
3634 this._state = "IN_HEX_ENTITY";
3635 } else {
3636 /** @type {string} */
3637 this._state = "IN_NUMERIC_ENTITY";
3638 this.IN_NUMERIC_ENTITY(undef);
3639 }
3640 };
3641 /**
3642 * @param {string} name
3643 * @return {undefined}
3644 */
3645 result.IN_NAMED_ENTITY = function(name) {
3646 if (";" === name) {
3647 if (this._sectionStart + 1 !== this._index) {
3648 this._parseNamedEntityStrict();
3649 if (this._sectionStart + 1 < this._index) {
3650 if (!has(this._baseState)) {
3651 if (!this._xmlMode) {
3652 this._parseLegacyEntity();
3653 }
3654 }
3655 } else {
3656 this._sectionStart++;
3657 }
3658 }
3659 this._state = this._baseState;
3660 } else {
3661 if (!isArguments(name)) {
3662 if (!ondata(name)) {
3663 if (!this._xmlMode) {
3664 if (!(this._sectionStart + 1 === this._index)) {
3665 if (has(this._baseState)) {
3666 if ("=" !== name) {
3667 this._parseNamedEntityStrict();
3668 }
3669 } else {
3670 this._parseLegacyEntity();
3671 }
3672 }
3673 }
3674 this._state = this._baseState;
3675 this[this._baseState](name);
3676 }
3677 }
3678 }
3679 };
3680 /**
3681 * @param {string} name
3682 * @return {undefined}
3683 */
3684 result.IN_NUMERIC_ENTITY = function(name) {
3685 if (";" === name) {
3686 this._state = this._baseState;
3687 if (this._sectionStart + 2 !== this._index) {
3688 this._decodeNumericEntity(2, 10);
3689 this._sectionStart = this._index + 1;
3690 }
3691 } else {
3692 if (!ondata(name)) {
3693 this._state = this._baseState;
3694 if (!this._xmlMode) {
3695 if (!(this._sectionStart + 2 === this._index)) {
3696 this._decodeNumericEntity(2, 10);
3697 this._sectionStart = this._index;
3698 }
3699 }
3700 this[this._baseState](name);
3701 }
3702 }
3703 };
3704 /**
3705 * @param {string} cl
3706 * @return {undefined}
3707 */
3708 result.IN_HEX_ENTITY = function(cl) {
3709 if (";" === cl) {
3710 this._state = this._baseState;
3711 if (this._sectionStart + 3 !== this._index) {
3712 this._decodeNumericEntity(3, 16);
3713 this._sectionStart = this._index + 1;
3714 }
3715 } else {
3716 if (!ondata(cl)) {
3717 if (cl < "a" || cl > "f") {
3718 if (cl < "A" || cl > "F") {
3719 this._state = this._baseState;
3720 if (!this._xmlMode) {
3721 if (!(this._sectionStart + 3 === this._index)) {
3722 this._decodeNumericEntity(3, 16);
3723 this._sectionStart = this._index;
3724 }
3725 }
3726 this[this._baseState](cl);
3727 }
3728 }
3729 }
3730 }
3731 };
3732 /**
3733 * @return {undefined}
3734 */
3735 self.prototype._parseNamedEntityStrict = function() {
3736 var sel = this._buffer.substring(this._sectionStart + 1, this._index);
3737 var selectors = this._xmlMode ? Block : nodes;
3738 if (selectors.hasOwnProperty(sel)) {
3739 this._emitPartial(selectors[sel]);
3740 this._sectionStart = this._index;
3741 }
3742 };
3743 /**
3744 * @return {?}
3745 */
3746 self.prototype._parseLegacyEntity = function() {
3747 var c = this._sectionStart + 1;
3748 /** @type {number} */
3749 var index = this._index - c;
3750 if (index > 6) {
3751 /** @type {number} */
3752 index = 6;
3753 }
3754 for (;index >= 2;) {
3755 var key = this._buffer.substr(c, index);
3756 if (client.hasOwnProperty(key)) {
3757 return this._emitPartial(client[key]), void(this._sectionStart += index + 1);
3758 }
3759 index--;
3760 }
3761 };
3762 /**
3763 * @param {number} opt_attributes
3764 * @param {number} replacementHash
3765 * @return {undefined}
3766 */
3767 self.prototype._decodeNumericEntity = function(opt_attributes, replacementHash) {
3768 var cDigit = this._buffer.substring(this._sectionStart + opt_attributes, this._index);
3769 /** @type {number} */
3770 var last = parseInt(cDigit, replacementHash);
3771 this._emitPartial(process(last));
3772 };
3773 /**
3774 * @return {undefined}
3775 */
3776 self.prototype._cleanup = function() {
3777 if (this._sectionStart < 0) {
3778 /** @type {string} */
3779 this._buffer = "";
3780 /** @type {number} */
3781 this._index = 0;
3782 } else {
3783 if (this._running) {
3784 if (this._state === state || ("RCDATA_STATE" === this._state || ("RAWTEXT_STATE" === this._state || ("PLAINTEXT_STATE" === this._state || "SCRIPT_DATA_STATE" === this._state)))) {
3785 if (this._sectionStart !== this._index) {
3786 this._cbs.ontext(this._buffer.substr(this._sectionStart));
3787 }
3788 /** @type {string} */
3789 this._buffer = "";
3790 /** @type {number} */
3791 this._index = 0;
3792 } else {
3793 if (this._sectionStart === this._index) {
3794 /** @type {string} */
3795 this._buffer = "";
3796 /** @type {number} */
3797 this._index = 0;
3798 } else {
3799 this._buffer = this._buffer.substr(this._sectionStart);
3800 this._index -= this._sectionStart;
3801 }
3802 }
3803 /** @type {number} */
3804 this._sectionStart = 0;
3805 }
3806 }
3807 };
3808 /**
3809 * @param {string} data
3810 * @return {undefined}
3811 */
3812 self.prototype.write = function(data) {
3813 if (this._ended) {
3814 this._cbs.onerror(Error(".write() after done!"));
3815 }
3816 this._buffer += data;
3817 this._parse();
3818 };
3819 /**
3820 * @return {undefined}
3821 */
3822 self.prototype._parse = function() {
3823 for (;this._index < this._buffer.length && this._running;) {
3824 var c = this._buffer.charAt(this._index);
3825 if (this._debug) {
3826 console.log("-> %j %s", c, this._state);
3827 }
3828 this[this._state](c);
3829 this._index++;
3830 }
3831 this._cleanup();
3832 };
3833 /**
3834 * @return {undefined}
3835 */
3836 self.prototype.pause = function() {
3837 /** @type {boolean} */
3838 this._running = false;
3839 };
3840 /**
3841 * @return {undefined}
3842 */
3843 self.prototype.resume = function() {
3844 /** @type {boolean} */
3845 this._running = true;
3846 if (this._index < this._buffer.length) {
3847 this._parse();
3848 }
3849 if (this._ended) {
3850 this._finish();
3851 }
3852 };
3853 /**
3854 * @return {undefined}
3855 */
3856 self.prototype.consumePlaintext = function() {
3857 /** @type {string} */
3858 this._state = "PLAINTEXT_STATE";
3859 };
3860 /**
3861 * @return {undefined}
3862 */
3863 self.prototype.consumeScriptData = function() {
3864 /** @type {string} */
3865 this._state = "SCRIPT_DATA_STATE";
3866 /** @type {string} */
3867 this._sequence = "script";
3868 };
3869 /**
3870 * @param {?} symbolizer
3871 * @return {undefined}
3872 */
3873 self.prototype.consumeRCData = function(symbolizer) {
3874 /** @type {string} */
3875 this._state = "RCDATA_STATE";
3876 this._sequence = symbolizer;
3877 };
3878 /**
3879 * @param {string} dataAndEvents
3880 * @return {undefined}
3881 */
3882 self.prototype.consumeRawtext = function(dataAndEvents) {
3883 /** @type {string} */
3884 this._state = "RAWTEXT_STATE";
3885 /** @type {string} */
3886 this._sequence = dataAndEvents;
3887 };
3888 /**
3889 * @param {string} data
3890 * @return {undefined}
3891 */
3892 self.prototype.end = function(data) {
3893 if (this._ended) {
3894 this._cbs.onerror(Error(".end() after done!"));
3895 }
3896 if (data) {
3897 this.write(data);
3898 }
3899 /** @type {boolean} */
3900 this._ended = true;
3901 if (this._running) {
3902 this._finish();
3903 }
3904 };
3905 /**
3906 * @return {undefined}
3907 */
3908 self.prototype._finish = function() {
3909 var data = this._buffer.substr(this._sectionStart);
3910 if (this._debug) {
3911 console.log("-| %s %j", this._state, data);
3912 }
3913 if ("AFTER_DOCTYPE_NAME" === this._state || ("AFTER_DT_PUBLIC" === this._state || ("BOGUS_EVIL_DOCTYPE" === this._state || ("AFTER_DT_SYSTEM" === this._state || (this._state === prev || this._state === next))))) {
3914 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer, this._systemBuffer, false);
3915 } else {
3916 if ("DT_PUBLIC_DQ" === this._state || "DT_PUBLIC_SQ" === this._state) {
3917 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer + data, this._systemBuffer, false);
3918 } else {
3919 if ("DT_SYSTEM_DQ" === this._state || "DT_SYSTEM_SQ" === this._state) {
3920 this._cbs.ondoctype(this._nameBuffer, this._valueBuffer, this._systemBuffer + data, false);
3921 } else {
3922 if ("BEFORE_DOCTYPE_NAME" === this._state) {
3923 this._cbs.ondoctype(null, null, null, false);
3924 } else {
3925 if ("DOCTYPE_NAME" === this._state) {
3926 this._cbs.ondoctype(this._nameBuffer + data, null, null, false);
3927 } else {
3928 if (this._state === partName) {
3929 this._state = this._baseState;
3930 this._finish();
3931 } else {
3932 if ("MARKUP_DECLARATION_OPEN" === this._state || ("BEFORE_COMMENT" === this._state || (this._state === value || ("BOGUS_COMMENT" === this._state || "COMMENT_START" === this._state)))) {
3933 this._cbs.oncomment(data);
3934 } else {
3935 if ("COMMENT_START_DASH" === this._state || "COMMENT_END_DASH" === this._state) {
3936 this._cbs.oncomment(data.slice(0, -1));
3937 } else {
3938 if ("COMMENT_END" === this._state) {
3939 this._cbs.oncomment(data.slice(0, -2));
3940 } else {
3941 if ("COMMENT_END_BANG" === this._state) {
3942 this._cbs.oncomment(data.slice(0, -3));
3943 } else {
3944 if (!(0 === data.length)) {
3945 if (!this._xmlMode && !has(this._baseState) || "IN_NAMED_ENTITY" !== this._state && ("IN_NUMERIC_ENTITY" !== this._state && "IN_HEX_ENTITY" !== this._state)) {
3946 if ("IN_NUMERIC_ENTITY" === this._state) {
3947 if (data.length > 2) {
3948 this._decodeNumericEntity(2, 10);
3949 } else {
3950 this._cbs.ontext(data);
3951 }
3952 } else {
3953 if ("IN_HEX_ENTITY" === this._state) {
3954 if (data.length > 3) {
3955 this._decodeNumericEntity(3, 16);
3956 } else {
3957 this._cbs.ontext(data);
3958 }
3959 } else {
3960 if ("IN_NAMED_ENTITY" === this._state) {
3961 if (data.length > 1) {
3962 this._parseLegacyEntity();
3963 }
3964 if (this._sectionStart < this._index) {
3965 this._state = this._baseState;
3966 this._finish();
3967 }
3968 } else {
3969 if ("IN_CDATA" === this._state || ("AFTER_CDATA_1" === this._state || "AFTER_CDATA_2" === this._state)) {
3970 this._cbs.oncdata(data);
3971 } else {
3972 if ("TAG_NAME" !== this._state) {
3973 if ("AFTER_CLOSING_TAG_NAME" !== this._state) {
3974 if (this._state !== cur) {
3975 if ("BEFORE_ATTRIBUTE_VALUE" !== this._state) {
3976 if ("AFTER_ATTRIBUTE_NAME" !== this._state) {
3977 if ("ATTRIBUTE_NAME" !== this._state) {
3978 if (this._state !== length) {
3979 if (this._state !== name) {
3980 if (this._state !== m) {
3981 if ("IN_CLOSING_TAG_NAME" !== this._state) {
3982 if ("BOGUS_DOCTYPE" !== this._state) {
3983 this._cbs.ontext(data);
3984 }
3985 }
3986 }
3987 }
3988 }
3989 }
3990 }
3991 }
3992 }
3993 }
3994 }
3995 }
3996 }
3997 }
3998 }
3999 } else {
4000 this._state = this._baseState;
4001 this._finish();
4002 }
4003 }
4004 }
4005 }
4006 }
4007 }
4008 }
4009 }
4010 }
4011 }
4012 }
4013 }
4014 this._cbs.onend();
4015 };
4016 /**
4017 * @return {undefined}
4018 */
4019 self.prototype.reset = function() {
4020 self.call(this, this._cbs, {
4021 xmlMode : this._xmlMode,
4022 decodeEntities : this._decodeEntities
4023 });
4024 };
4025 /**
4026 * @return {?}
4027 */
4028 self.prototype._getSection = function() {
4029 return this._buffer.substring(this._sectionStart, this._index);
4030 };
4031 /**
4032 * @return {?}
4033 */
4034 self.prototype._getEndingSection = function() {
4035 var _getSection = this._getSection();
4036 return this._sectionStart = -1, _getSection;
4037 };
4038 /**
4039 * @return {?}
4040 */
4041 self.prototype._getPartialSection = function() {
4042 var _getSection = this._getSection();
4043 return this._sectionStart = this._index + 1, _getSection;
4044 };
4045 /**
4046 * @param {string} rawData
4047 * @return {undefined}
4048 */
4049 self.prototype._emitPartial = function(rawData) {
4050 if (has(this._baseState)) {
4051 this._valueBuffer += rawData;
4052 } else {
4053 this._cbs.ontext(rawData);
4054 }
4055 };
4056 }, {
4057 "entities/lib/decode_codepoint.js" : 3,
4058 "entities/maps/entities.json" : 5,
4059 "entities/maps/legacy.json" : 6,
4060 "entities/maps/xml.json" : 7
4061 }],
4062 3 : [function(proceed, module, dataAndEvents) {
4063 var value = proceed("../maps/decode.json");
4064 /**
4065 * @param {number} k
4066 * @return {?}
4067 */
4068 module.exports = function(k) {
4069 if (k >= 55296 && k <= 57343 || k > 1114111) {
4070 return "\u00ef\u00bf\u00bd";
4071 }
4072 if (k in value) {
4073 k = value[k];
4074 }
4075 /** @type {string} */
4076 var par = "";
4077 return k > 65535 && (k -= 65536, par += String.fromCharCode(k >>> 10 & 1023 | 55296), k = 56320 | 1023 & k), par += String.fromCharCode(k);
4078 };
4079 }, {
4080 "../maps/decode.json" : 4
4081 }],
4082 4 : [function(dataAndEvents, module, deepDataAndEvents) {
4083 module.exports = {
4084 0 : 65533,
4085 128 : 8364,
4086 130 : 8218,
4087 131 : 402,
4088 132 : 8222,
4089 133 : 8230,
4090 134 : 8224,
4091 135 : 8225,
4092 136 : 710,
4093 137 : 8240,
4094 138 : 352,
4095 139 : 8249,
4096 140 : 338,
4097 142 : 381,
4098 145 : 8216,
4099 146 : 8217,
4100 147 : 8220,
4101 148 : 8221,
4102 149 : 8226,
4103 150 : 8211,
4104 151 : 8212,
4105 152 : 732,
4106 153 : 8482,
4107 154 : 353,
4108 155 : 8250,
4109 156 : 339,
4110 158 : 382,
4111 159 : 376
4112 };
4113 }, {}],
4114 5 : [function(dataAndEvents, module, deepDataAndEvents) {
4115 module.exports = {
4116 Aacute : "\u00c3\u0081",
4117 aacute : "\u00c3\u00a1",
4118 Abreve : "\u00c4\u201a",
4119 abreve : "\u00c4\u0192",
4120 ac : "\u00e2\u02c6\u00be",
4121 acd : "\u00e2\u02c6\u00bf",
4122 acE : "\u00e2\u02c6\u00be\u00cc\u00b3",
4123 Acirc : "\u00c3\u201a",
4124 acirc : "\u00c3\u00a2",
4125 acute : "\u00c2\u00b4",
4126 Acy : "\u00d0\u0090",
4127 acy : "\u00d0\u00b0",
4128 AElig : "\u00c3\u2020",
4129 aelig : "\u00c3\u00a6",
4130 af : "\u00e2\u0081\u00a1",
4131 Afr : "\u00f0\u009d\u201d\u201e",
4132 afr : "\u00f0\u009d\u201d\u017e",
4133 Agrave : "\u00c3\u20ac",
4134 agrave : "\u00c3 ",
4135 alefsym : "\u00e2\u201e\u00b5",
4136 aleph : "\u00e2\u201e\u00b5",
4137 Alpha : "\u00ce\u2018",
4138 alpha : "\u00ce\u00b1",
4139 Amacr : "\u00c4\u20ac",
4140 amacr : "\u00c4\u0081",
4141 amalg : "\u00e2\u00a8\u00bf",
4142 amp : "&",
4143 AMP : "&",
4144 andand : "\u00e2\u00a9\u2022",
4145 And : "\u00e2\u00a9\u201c",
4146 and : "\u00e2\u02c6\u00a7",
4147 andd : "\u00e2\u00a9\u0153",
4148 andslope : "\u00e2\u00a9\u02dc",
4149 andv : "\u00e2\u00a9\u0161",
4150 ang : "\u00e2\u02c6 ",
4151 ange : "\u00e2\u00a6\u00a4",
4152 angle : "\u00e2\u02c6 ",
4153 angmsdaa : "\u00e2\u00a6\u00a8",
4154 angmsdab : "\u00e2\u00a6\u00a9",
4155 angmsdac : "\u00e2\u00a6\u00aa",
4156 angmsdad : "\u00e2\u00a6\u00ab",
4157 angmsdae : "\u00e2\u00a6\u00ac",
4158 angmsdaf : "\u00e2\u00a6\u00ad",
4159 angmsdag : "\u00e2\u00a6\u00ae",
4160 angmsdah : "\u00e2\u00a6\u00af",
4161 angmsd : "\u00e2\u02c6\u00a1",
4162 angrt : "\u00e2\u02c6\u0178",
4163 angrtvb : "\u00e2\u0160\u00be",
4164 angrtvbd : "\u00e2\u00a6\u009d",
4165 angsph : "\u00e2\u02c6\u00a2",
4166 angst : "\u00c3\u2026",
4167 angzarr : "\u00e2\u008d\u00bc",
4168 Aogon : "\u00c4\u201e",
4169 aogon : "\u00c4\u2026",
4170 Aopf : "\u00f0\u009d\u201d\u00b8",
4171 aopf : "\u00f0\u009d\u2022\u2019",
4172 apacir : "\u00e2\u00a9\u00af",
4173 ap : "\u00e2\u2030\u02c6",
4174 apE : "\u00e2\u00a9\u00b0",
4175 ape : "\u00e2\u2030\u0160",
4176 apid : "\u00e2\u2030\u2039",
4177 apos : "'",
4178 ApplyFunction : "\u00e2\u0081\u00a1",
4179 approx : "\u00e2\u2030\u02c6",
4180 approxeq : "\u00e2\u2030\u0160",
4181 Aring : "\u00c3\u2026",
4182 aring : "\u00c3\u00a5",
4183 Ascr : "\u00f0\u009d\u2019\u0153",
4184 ascr : "\u00f0\u009d\u2019\u00b6",
4185 Assign : "\u00e2\u2030\u201d",
4186 ast : "*",
4187 asymp : "\u00e2\u2030\u02c6",
4188 asympeq : "\u00e2\u2030\u008d",
4189 Atilde : "\u00c3\u0192",
4190 atilde : "\u00c3\u00a3",
4191 Auml : "\u00c3\u201e",
4192 auml : "\u00c3\u00a4",
4193 awconint : "\u00e2\u02c6\u00b3",
4194 awint : "\u00e2\u00a8\u2018",
4195 backcong : "\u00e2\u2030\u0152",
4196 backepsilon : "\u00cf\u00b6",
4197 backprime : "\u00e2\u20ac\u00b5",
4198 backsim : "\u00e2\u02c6\u00bd",
4199 backsimeq : "\u00e2\u2039\u008d",
4200 Backslash : "\u00e2\u02c6\u2013",
4201 Barv : "\u00e2\u00ab\u00a7",
4202 barvee : "\u00e2\u0160\u00bd",
4203 barwed : "\u00e2\u0152\u2026",
4204 Barwed : "\u00e2\u0152\u2020",
4205 barwedge : "\u00e2\u0152\u2026",
4206 bbrk : "\u00e2\u017d\u00b5",
4207 bbrktbrk : "\u00e2\u017d\u00b6",
4208 bcong : "\u00e2\u2030\u0152",
4209 Bcy : "\u00d0\u2018",
4210 bcy : "\u00d0\u00b1",
4211 bdquo : "\u00e2\u20ac\u017e",
4212 becaus : "\u00e2\u02c6\u00b5",
4213 because : "\u00e2\u02c6\u00b5",
4214 Because : "\u00e2\u02c6\u00b5",
4215 bemptyv : "\u00e2\u00a6\u00b0",
4216 bepsi : "\u00cf\u00b6",
4217 bernou : "\u00e2\u201e\u00ac",
4218 Bernoullis : "\u00e2\u201e\u00ac",
4219 Beta : "\u00ce\u2019",
4220 beta : "\u00ce\u00b2",
4221 beth : "\u00e2\u201e\u00b6",
4222 between : "\u00e2\u2030\u00ac",
4223 Bfr : "\u00f0\u009d\u201d\u2026",
4224 bfr : "\u00f0\u009d\u201d\u0178",
4225 bigcap : "\u00e2\u2039\u201a",
4226 bigcirc : "\u00e2\u2014\u00af",
4227 bigcup : "\u00e2\u2039\u0192",
4228 bigodot : "\u00e2\u00a8\u20ac",
4229 bigoplus : "\u00e2\u00a8\u0081",
4230 bigotimes : "\u00e2\u00a8\u201a",
4231 bigsqcup : "\u00e2\u00a8\u2020",
4232 bigstar : "\u00e2\u02dc\u2026",
4233 bigtriangledown : "\u00e2\u2013\u00bd",
4234 bigtriangleup : "\u00e2\u2013\u00b3",
4235 biguplus : "\u00e2\u00a8\u201e",
4236 bigvee : "\u00e2\u2039\u0081",
4237 bigwedge : "\u00e2\u2039\u20ac",
4238 bkarow : "\u00e2\u00a4\u008d",
4239 blacklozenge : "\u00e2\u00a7\u00ab",
4240 blacksquare : "\u00e2\u2013\u00aa",
4241 blacktriangle : "\u00e2\u2013\u00b4",
4242 blacktriangledown : "\u00e2\u2013\u00be",
4243 blacktriangleleft : "\u00e2\u2014\u201a",
4244 blacktriangleright : "\u00e2\u2013\u00b8",
4245 blank : "\u00e2\u0090\u00a3",
4246 blk12 : "\u00e2\u2013\u2019",
4247 blk14 : "\u00e2\u2013\u2018",
4248 blk34 : "\u00e2\u2013\u201c",
4249 block : "\u00e2\u2013\u02c6",
4250 bne : "=\u00e2\u0192\u00a5",
4251 bnequiv : "\u00e2\u2030\u00a1\u00e2\u0192\u00a5",
4252 bNot : "\u00e2\u00ab\u00ad",
4253 bnot : "\u00e2\u0152\u0090",
4254 Bopf : "\u00f0\u009d\u201d\u00b9",
4255 bopf : "\u00f0\u009d\u2022\u201c",
4256 bot : "\u00e2\u0160\u00a5",
4257 bottom : "\u00e2\u0160\u00a5",
4258 bowtie : "\u00e2\u2039\u02c6",
4259 boxbox : "\u00e2\u00a7\u2030",
4260 boxdl : "\u00e2\u201d\u0090",
4261 boxdL : "\u00e2\u2022\u2022",
4262 boxDl : "\u00e2\u2022\u2013",
4263 boxDL : "\u00e2\u2022\u2014",
4264 boxdr : "\u00e2\u201d\u0152",
4265 boxdR : "\u00e2\u2022\u2019",
4266 boxDr : "\u00e2\u2022\u201c",
4267 boxDR : "\u00e2\u2022\u201d",
4268 boxh : "\u00e2\u201d\u20ac",
4269 boxH : "\u00e2\u2022\u0090",
4270 boxhd : "\u00e2\u201d\u00ac",
4271 boxHd : "\u00e2\u2022\u00a4",
4272 boxhD : "\u00e2\u2022\u00a5",
4273 boxHD : "\u00e2\u2022\u00a6",
4274 boxhu : "\u00e2\u201d\u00b4",
4275 boxHu : "\u00e2\u2022\u00a7",
4276 boxhU : "\u00e2\u2022\u00a8",
4277 boxHU : "\u00e2\u2022\u00a9",
4278 boxminus : "\u00e2\u0160\u0178",
4279 boxplus : "\u00e2\u0160\u017e",
4280 boxtimes : "\u00e2\u0160 ",
4281 boxul : "\u00e2\u201d\u02dc",
4282 boxuL : "\u00e2\u2022\u203a",
4283 boxUl : "\u00e2\u2022\u0153",
4284 boxUL : "\u00e2\u2022\u009d",
4285 boxur : "\u00e2\u201d\u201d",
4286 boxuR : "\u00e2\u2022\u02dc",
4287 boxUr : "\u00e2\u2022\u2122",
4288 boxUR : "\u00e2\u2022\u0161",
4289 boxv : "\u00e2\u201d\u201a",
4290 boxV : "\u00e2\u2022\u2018",
4291 boxvh : "\u00e2\u201d\u00bc",
4292 boxvH : "\u00e2\u2022\u00aa",
4293 boxVh : "\u00e2\u2022\u00ab",
4294 boxVH : "\u00e2\u2022\u00ac",
4295 boxvl : "\u00e2\u201d\u00a4",
4296 boxvL : "\u00e2\u2022\u00a1",
4297 boxVl : "\u00e2\u2022\u00a2",
4298 boxVL : "\u00e2\u2022\u00a3",
4299 boxvr : "\u00e2\u201d\u0153",
4300 boxvR : "\u00e2\u2022\u017e",
4301 boxVr : "\u00e2\u2022\u0178",
4302 boxVR : "\u00e2\u2022 ",
4303 bprime : "\u00e2\u20ac\u00b5",
4304 breve : "\u00cb\u02dc",
4305 Breve : "\u00cb\u02dc",
4306 brvbar : "\u00c2\u00a6",
4307 bscr : "\u00f0\u009d\u2019\u00b7",
4308 Bscr : "\u00e2\u201e\u00ac",
4309 bsemi : "\u00e2\u0081\u008f",
4310 bsim : "\u00e2\u02c6\u00bd",
4311 bsime : "\u00e2\u2039\u008d",
4312 bsolb : "\u00e2\u00a7\u2026",
4313 bsol : "\\",
4314 bsolhsub : "\u00e2\u0178\u02c6",
4315 bull : "\u00e2\u20ac\u00a2",
4316 bullet : "\u00e2\u20ac\u00a2",
4317 bump : "\u00e2\u2030\u017d",
4318 bumpE : "\u00e2\u00aa\u00ae",
4319 bumpe : "\u00e2\u2030\u008f",
4320 Bumpeq : "\u00e2\u2030\u017d",
4321 bumpeq : "\u00e2\u2030\u008f",
4322 Cacute : "\u00c4\u2020",
4323 cacute : "\u00c4\u2021",
4324 capand : "\u00e2\u00a9\u201e",
4325 capbrcup : "\u00e2\u00a9\u2030",
4326 capcap : "\u00e2\u00a9\u2039",
4327 cap : "\u00e2\u02c6\u00a9",
4328 Cap : "\u00e2\u2039\u2019",
4329 capcup : "\u00e2\u00a9\u2021",
4330 capdot : "\u00e2\u00a9\u20ac",
4331 CapitalDifferentialD : "\u00e2\u2026\u2026",
4332 caps : "\u00e2\u02c6\u00a9\u00ef\u00b8\u20ac",
4333 caret : "\u00e2\u0081\u0081",
4334 caron : "\u00cb\u2021",
4335 Cayleys : "\u00e2\u201e\u00ad",
4336 ccaps : "\u00e2\u00a9\u008d",
4337 Ccaron : "\u00c4\u0152",
4338 ccaron : "\u00c4\u008d",
4339 Ccedil : "\u00c3\u2021",
4340 ccedil : "\u00c3\u00a7",
4341 Ccirc : "\u00c4\u02c6",
4342 ccirc : "\u00c4\u2030",
4343 Cconint : "\u00e2\u02c6\u00b0",
4344 ccups : "\u00e2\u00a9\u0152",
4345 ccupssm : "\u00e2\u00a9\u0090",
4346 Cdot : "\u00c4\u0160",
4347 cdot : "\u00c4\u2039",
4348 cedil : "\u00c2\u00b8",
4349 Cedilla : "\u00c2\u00b8",
4350 cemptyv : "\u00e2\u00a6\u00b2",
4351 cent : "\u00c2\u00a2",
4352 centerdot : "\u00c2\u00b7",
4353 CenterDot : "\u00c2\u00b7",
4354 cfr : "\u00f0\u009d\u201d ",
4355 Cfr : "\u00e2\u201e\u00ad",
4356 CHcy : "\u00d0\u00a7",
4357 chcy : "\u00d1\u2021",
4358 check : "\u00e2\u0153\u201c",
4359 checkmark : "\u00e2\u0153\u201c",
4360 Chi : "\u00ce\u00a7",
4361 chi : "\u00cf\u2021",
4362 circ : "\u00cb\u2020",
4363 circeq : "\u00e2\u2030\u2014",
4364 circlearrowleft : "\u00e2\u2020\u00ba",
4365 circlearrowright : "\u00e2\u2020\u00bb",
4366 circledast : "\u00e2\u0160\u203a",
4367 circledcirc : "\u00e2\u0160\u0161",
4368 circleddash : "\u00e2\u0160\u009d",
4369 CircleDot : "\u00e2\u0160\u2122",
4370 circledR : "\u00c2\u00ae",
4371 circledS : "\u00e2\u201c\u02c6",
4372 CircleMinus : "\u00e2\u0160\u2013",
4373 CirclePlus : "\u00e2\u0160\u2022",
4374 CircleTimes : "\u00e2\u0160\u2014",
4375 cir : "\u00e2\u2014\u2039",
4376 cirE : "\u00e2\u00a7\u0192",
4377 cire : "\u00e2\u2030\u2014",
4378 cirfnint : "\u00e2\u00a8\u0090",
4379 cirmid : "\u00e2\u00ab\u00af",
4380 cirscir : "\u00e2\u00a7\u201a",
4381 ClockwiseContourIntegral : "\u00e2\u02c6\u00b2",
4382 CloseCurlyDoubleQuote : "\u00e2\u20ac\u009d",
4383 CloseCurlyQuote : "\u00e2\u20ac\u2122",
4384 clubs : "\u00e2\u2122\u00a3",
4385 clubsuit : "\u00e2\u2122\u00a3",
4386 colon : ":",
4387 Colon : "\u00e2\u02c6\u00b7",
4388 Colone : "\u00e2\u00a9\u00b4",
4389 colone : "\u00e2\u2030\u201d",
4390 coloneq : "\u00e2\u2030\u201d",
4391 comma : ",",
4392 commat : "@",
4393 comp : "\u00e2\u02c6\u0081",
4394 compfn : "\u00e2\u02c6\u02dc",
4395 complement : "\u00e2\u02c6\u0081",
4396 complexes : "\u00e2\u201e\u201a",
4397 cong : "\u00e2\u2030\u2026",
4398 congdot : "\u00e2\u00a9\u00ad",
4399 Congruent : "\u00e2\u2030\u00a1",
4400 conint : "\u00e2\u02c6\u00ae",
4401 Conint : "\u00e2\u02c6\u00af",
4402 ContourIntegral : "\u00e2\u02c6\u00ae",
4403 copf : "\u00f0\u009d\u2022\u201d",
4404 Copf : "\u00e2\u201e\u201a",
4405 coprod : "\u00e2\u02c6\u0090",
4406 Coproduct : "\u00e2\u02c6\u0090",
4407 copy : "\u00c2\u00a9",
4408 COPY : "\u00c2\u00a9",
4409 copysr : "\u00e2\u201e\u2014",
4410 CounterClockwiseContourIntegral : "\u00e2\u02c6\u00b3",
4411 crarr : "\u00e2\u2020\u00b5",
4412 cross : "\u00e2\u0153\u2014",
4413 Cross : "\u00e2\u00a8\u00af",
4414 Cscr : "\u00f0\u009d\u2019\u017e",
4415 cscr : "\u00f0\u009d\u2019\u00b8",
4416 csub : "\u00e2\u00ab\u008f",
4417 csube : "\u00e2\u00ab\u2018",
4418 csup : "\u00e2\u00ab\u0090",
4419 csupe : "\u00e2\u00ab\u2019",
4420 ctdot : "\u00e2\u2039\u00af",
4421 cudarrl : "\u00e2\u00a4\u00b8",
4422 cudarrr : "\u00e2\u00a4\u00b5",
4423 cuepr : "\u00e2\u2039\u017e",
4424 cuesc : "\u00e2\u2039\u0178",
4425 cularr : "\u00e2\u2020\u00b6",
4426 cularrp : "\u00e2\u00a4\u00bd",
4427 cupbrcap : "\u00e2\u00a9\u02c6",
4428 cupcap : "\u00e2\u00a9\u2020",
4429 CupCap : "\u00e2\u2030\u008d",
4430 cup : "\u00e2\u02c6\u00aa",
4431 Cup : "\u00e2\u2039\u201c",
4432 cupcup : "\u00e2\u00a9\u0160",
4433 cupdot : "\u00e2\u0160\u008d",
4434 cupor : "\u00e2\u00a9\u2026",
4435 cups : "\u00e2\u02c6\u00aa\u00ef\u00b8\u20ac",
4436 curarr : "\u00e2\u2020\u00b7",
4437 curarrm : "\u00e2\u00a4\u00bc",
4438 curlyeqprec : "\u00e2\u2039\u017e",
4439 curlyeqsucc : "\u00e2\u2039\u0178",
4440 curlyvee : "\u00e2\u2039\u017d",
4441 curlywedge : "\u00e2\u2039\u008f",
4442 curren : "\u00c2\u00a4",
4443 curvearrowleft : "\u00e2\u2020\u00b6",
4444 curvearrowright : "\u00e2\u2020\u00b7",
4445 cuvee : "\u00e2\u2039\u017d",
4446 cuwed : "\u00e2\u2039\u008f",
4447 cwconint : "\u00e2\u02c6\u00b2",
4448 cwint : "\u00e2\u02c6\u00b1",
4449 cylcty : "\u00e2\u0152\u00ad",
4450 dagger : "\u00e2\u20ac ",
4451 Dagger : "\u00e2\u20ac\u00a1",
4452 daleth : "\u00e2\u201e\u00b8",
4453 darr : "\u00e2\u2020\u201c",
4454 Darr : "\u00e2\u2020\u00a1",
4455 dArr : "\u00e2\u2021\u201c",
4456 dash : "\u00e2\u20ac\u0090",
4457 Dashv : "\u00e2\u00ab\u00a4",
4458 dashv : "\u00e2\u0160\u00a3",
4459 dbkarow : "\u00e2\u00a4\u008f",
4460 dblac : "\u00cb\u009d",
4461 Dcaron : "\u00c4\u017d",
4462 dcaron : "\u00c4\u008f",
4463 Dcy : "\u00d0\u201d",
4464 dcy : "\u00d0\u00b4",
4465 ddagger : "\u00e2\u20ac\u00a1",
4466 ddarr : "\u00e2\u2021\u0160",
4467 DD : "\u00e2\u2026\u2026",
4468 dd : "\u00e2\u2026\u2020",
4469 DDotrahd : "\u00e2\u00a4\u2018",
4470 ddotseq : "\u00e2\u00a9\u00b7",
4471 deg : "\u00c2\u00b0",
4472 Del : "\u00e2\u02c6\u2021",
4473 Delta : "\u00ce\u201d",
4474 delta : "\u00ce\u00b4",
4475 demptyv : "\u00e2\u00a6\u00b1",
4476 dfisht : "\u00e2\u00a5\u00bf",
4477 Dfr : "\u00f0\u009d\u201d\u2021",
4478 dfr : "\u00f0\u009d\u201d\u00a1",
4479 dHar : "\u00e2\u00a5\u00a5",
4480 dharl : "\u00e2\u2021\u0192",
4481 dharr : "\u00e2\u2021\u201a",
4482 DiacriticalAcute : "\u00c2\u00b4",
4483 DiacriticalDot : "\u00cb\u2122",
4484 DiacriticalDoubleAcute : "\u00cb\u009d",
4485 DiacriticalGrave : "`",
4486 DiacriticalTilde : "\u00cb\u0153",
4487 diam : "\u00e2\u2039\u201e",
4488 diamond : "\u00e2\u2039\u201e",
4489 Diamond : "\u00e2\u2039\u201e",
4490 diamondsuit : "\u00e2\u2122\u00a6",
4491 diams : "\u00e2\u2122\u00a6",
4492 die : "\u00c2\u00a8",
4493 DifferentialD : "\u00e2\u2026\u2020",
4494 digamma : "\u00cf\u009d",
4495 disin : "\u00e2\u2039\u00b2",
4496 div : "\u00c3\u00b7",
4497 divide : "\u00c3\u00b7",
4498 divideontimes : "\u00e2\u2039\u2021",
4499 divonx : "\u00e2\u2039\u2021",
4500 DJcy : "\u00d0\u201a",
4501 djcy : "\u00d1\u2019",
4502 dlcorn : "\u00e2\u0152\u017e",
4503 dlcrop : "\u00e2\u0152\u008d",
4504 dollar : "$",
4505 Dopf : "\u00f0\u009d\u201d\u00bb",
4506 dopf : "\u00f0\u009d\u2022\u2022",
4507 Dot : "\u00c2\u00a8",
4508 dot : "\u00cb\u2122",
4509 DotDot : "\u00e2\u0192\u0153",
4510 doteq : "\u00e2\u2030\u0090",
4511 doteqdot : "\u00e2\u2030\u2018",
4512 DotEqual : "\u00e2\u2030\u0090",
4513 dotminus : "\u00e2\u02c6\u00b8",
4514 dotplus : "\u00e2\u02c6\u201d",
4515 dotsquare : "\u00e2\u0160\u00a1",
4516 doublebarwedge : "\u00e2\u0152\u2020",
4517 DoubleContourIntegral : "\u00e2\u02c6\u00af",
4518 DoubleDot : "\u00c2\u00a8",
4519 DoubleDownArrow : "\u00e2\u2021\u201c",
4520 DoubleLeftArrow : "\u00e2\u2021\u0090",
4521 DoubleLeftRightArrow : "\u00e2\u2021\u201d",
4522 DoubleLeftTee : "\u00e2\u00ab\u00a4",
4523 DoubleLongLeftArrow : "\u00e2\u0178\u00b8",
4524 DoubleLongLeftRightArrow : "\u00e2\u0178\u00ba",
4525 DoubleLongRightArrow : "\u00e2\u0178\u00b9",
4526 DoubleRightArrow : "\u00e2\u2021\u2019",
4527 DoubleRightTee : "\u00e2\u0160\u00a8",
4528 DoubleUpArrow : "\u00e2\u2021\u2018",
4529 DoubleUpDownArrow : "\u00e2\u2021\u2022",
4530 DoubleVerticalBar : "\u00e2\u02c6\u00a5",
4531 DownArrowBar : "\u00e2\u00a4\u201c",
4532 downarrow : "\u00e2\u2020\u201c",
4533 DownArrow : "\u00e2\u2020\u201c",
4534 Downarrow : "\u00e2\u2021\u201c",
4535 DownArrowUpArrow : "\u00e2\u2021\u00b5",
4536 DownBreve : "\u00cc\u2018",
4537 downdownarrows : "\u00e2\u2021\u0160",
4538 downharpoonleft : "\u00e2\u2021\u0192",
4539 downharpoonright : "\u00e2\u2021\u201a",
4540 DownLeftRightVector : "\u00e2\u00a5\u0090",
4541 DownLeftTeeVector : "\u00e2\u00a5\u017e",
4542 DownLeftVectorBar : "\u00e2\u00a5\u2013",
4543 DownLeftVector : "\u00e2\u2020\u00bd",
4544 DownRightTeeVector : "\u00e2\u00a5\u0178",
4545 DownRightVectorBar : "\u00e2\u00a5\u2014",
4546 DownRightVector : "\u00e2\u2021\u0081",
4547 DownTeeArrow : "\u00e2\u2020\u00a7",
4548 DownTee : "\u00e2\u0160\u00a4",
4549 drbkarow : "\u00e2\u00a4\u0090",
4550 drcorn : "\u00e2\u0152\u0178",
4551 drcrop : "\u00e2\u0152\u0152",
4552 Dscr : "\u00f0\u009d\u2019\u0178",
4553 dscr : "\u00f0\u009d\u2019\u00b9",
4554 DScy : "\u00d0\u2026",
4555 dscy : "\u00d1\u2022",
4556 dsol : "\u00e2\u00a7\u00b6",
4557 Dstrok : "\u00c4\u0090",
4558 dstrok : "\u00c4\u2018",
4559 dtdot : "\u00e2\u2039\u00b1",
4560 dtri : "\u00e2\u2013\u00bf",
4561 dtrif : "\u00e2\u2013\u00be",
4562 duarr : "\u00e2\u2021\u00b5",
4563 duhar : "\u00e2\u00a5\u00af",
4564 dwangle : "\u00e2\u00a6\u00a6",
4565 DZcy : "\u00d0\u008f",
4566 dzcy : "\u00d1\u0178",
4567 dzigrarr : "\u00e2\u0178\u00bf",
4568 Eacute : "\u00c3\u2030",
4569 eacute : "\u00c3\u00a9",
4570 easter : "\u00e2\u00a9\u00ae",
4571 Ecaron : "\u00c4\u0161",
4572 ecaron : "\u00c4\u203a",
4573 Ecirc : "\u00c3\u0160",
4574 ecirc : "\u00c3\u00aa",
4575 ecir : "\u00e2\u2030\u2013",
4576 ecolon : "\u00e2\u2030\u2022",
4577 Ecy : "\u00d0\u00ad",
4578 ecy : "\u00d1\u008d",
4579 eDDot : "\u00e2\u00a9\u00b7",
4580 Edot : "\u00c4\u2013",
4581 edot : "\u00c4\u2014",
4582 eDot : "\u00e2\u2030\u2018",
4583 ee : "\u00e2\u2026\u2021",
4584 efDot : "\u00e2\u2030\u2019",
4585 Efr : "\u00f0\u009d\u201d\u02c6",
4586 efr : "\u00f0\u009d\u201d\u00a2",
4587 eg : "\u00e2\u00aa\u0161",
4588 Egrave : "\u00c3\u02c6",
4589 egrave : "\u00c3\u00a8",
4590 egs : "\u00e2\u00aa\u2013",
4591 egsdot : "\u00e2\u00aa\u02dc",
4592 el : "\u00e2\u00aa\u2122",
4593 Element : "\u00e2\u02c6\u02c6",
4594 elinters : "\u00e2\u008f\u00a7",
4595 ell : "\u00e2\u201e\u201c",
4596 els : "\u00e2\u00aa\u2022",
4597 elsdot : "\u00e2\u00aa\u2014",
4598 Emacr : "\u00c4\u2019",
4599 emacr : "\u00c4\u201c",
4600 empty : "\u00e2\u02c6\u2026",
4601 emptyset : "\u00e2\u02c6\u2026",
4602 EmptySmallSquare : "\u00e2\u2014\u00bb",
4603 emptyv : "\u00e2\u02c6\u2026",
4604 EmptyVerySmallSquare : "\u00e2\u2013\u00ab",
4605 emsp13 : "\u00e2\u20ac\u201e",
4606 emsp14 : "\u00e2\u20ac\u2026",
4607 emsp : "\u00e2\u20ac\u0192",
4608 ENG : "\u00c5\u0160",
4609 eng : "\u00c5\u2039",
4610 ensp : "\u00e2\u20ac\u201a",
4611 Eogon : "\u00c4\u02dc",
4612 eogon : "\u00c4\u2122",
4613 Eopf : "\u00f0\u009d\u201d\u00bc",
4614 eopf : "\u00f0\u009d\u2022\u2013",
4615 epar : "\u00e2\u2039\u2022",
4616 eparsl : "\u00e2\u00a7\u00a3",
4617 eplus : "\u00e2\u00a9\u00b1",
4618 epsi : "\u00ce\u00b5",
4619 Epsilon : "\u00ce\u2022",
4620 epsilon : "\u00ce\u00b5",
4621 epsiv : "\u00cf\u00b5",
4622 eqcirc : "\u00e2\u2030\u2013",
4623 eqcolon : "\u00e2\u2030\u2022",
4624 eqsim : "\u00e2\u2030\u201a",
4625 eqslantgtr : "\u00e2\u00aa\u2013",
4626 eqslantless : "\u00e2\u00aa\u2022",
4627 Equal : "\u00e2\u00a9\u00b5",
4628 equals : "=",
4629 EqualTilde : "\u00e2\u2030\u201a",
4630 equest : "\u00e2\u2030\u0178",
4631 Equilibrium : "\u00e2\u2021\u0152",
4632 equiv : "\u00e2\u2030\u00a1",
4633 equivDD : "\u00e2\u00a9\u00b8",
4634 eqvparsl : "\u00e2\u00a7\u00a5",
4635 erarr : "\u00e2\u00a5\u00b1",
4636 erDot : "\u00e2\u2030\u201c",
4637 escr : "\u00e2\u201e\u00af",
4638 Escr : "\u00e2\u201e\u00b0",
4639 esdot : "\u00e2\u2030\u0090",
4640 Esim : "\u00e2\u00a9\u00b3",
4641 esim : "\u00e2\u2030\u201a",
4642 Eta : "\u00ce\u2014",
4643 eta : "\u00ce\u00b7",
4644 ETH : "\u00c3\u0090",
4645 eth : "\u00c3\u00b0",
4646 Euml : "\u00c3\u2039",
4647 euml : "\u00c3\u00ab",
4648 euro : "\u00e2\u201a\u00ac",
4649 excl : "!",
4650 exist : "\u00e2\u02c6\u0192",
4651 Exists : "\u00e2\u02c6\u0192",
4652 expectation : "\u00e2\u201e\u00b0",
4653 exponentiale : "\u00e2\u2026\u2021",
4654 ExponentialE : "\u00e2\u2026\u2021",
4655 fallingdotseq : "\u00e2\u2030\u2019",
4656 Fcy : "\u00d0\u00a4",
4657 fcy : "\u00d1\u201e",
4658 female : "\u00e2\u2122\u20ac",
4659 ffilig : "\u00ef\u00ac\u0192",
4660 fflig : "\u00ef\u00ac\u20ac",
4661 ffllig : "\u00ef\u00ac\u201e",
4662 Ffr : "\u00f0\u009d\u201d\u2030",
4663 ffr : "\u00f0\u009d\u201d\u00a3",
4664 filig : "\u00ef\u00ac\u0081",
4665 FilledSmallSquare : "\u00e2\u2014\u00bc",
4666 FilledVerySmallSquare : "\u00e2\u2013\u00aa",
4667 fjlig : "fj",
4668 flat : "\u00e2\u2122\u00ad",
4669 fllig : "\u00ef\u00ac\u201a",
4670 fltns : "\u00e2\u2013\u00b1",
4671 fnof : "\u00c6\u2019",
4672 Fopf : "\u00f0\u009d\u201d\u00bd",
4673 fopf : "\u00f0\u009d\u2022\u2014",
4674 forall : "\u00e2\u02c6\u20ac",
4675 ForAll : "\u00e2\u02c6\u20ac",
4676 fork : "\u00e2\u2039\u201d",
4677 forkv : "\u00e2\u00ab\u2122",
4678 Fouriertrf : "\u00e2\u201e\u00b1",
4679 fpartint : "\u00e2\u00a8\u008d",
4680 frac12 : "\u00c2\u00bd",
4681 frac13 : "\u00e2\u2026\u201c",
4682 frac14 : "\u00c2\u00bc",
4683 frac15 : "\u00e2\u2026\u2022",
4684 frac16 : "\u00e2\u2026\u2122",
4685 frac18 : "\u00e2\u2026\u203a",
4686 frac23 : "\u00e2\u2026\u201d",
4687 frac25 : "\u00e2\u2026\u2013",
4688 frac34 : "\u00c2\u00be",
4689 frac35 : "\u00e2\u2026\u2014",
4690 frac38 : "\u00e2\u2026\u0153",
4691 frac45 : "\u00e2\u2026\u02dc",
4692 frac56 : "\u00e2\u2026\u0161",
4693 frac58 : "\u00e2\u2026\u009d",
4694 frac78 : "\u00e2\u2026\u017e",
4695 frasl : "\u00e2\u0081\u201e",
4696 frown : "\u00e2\u0152\u00a2",
4697 fscr : "\u00f0\u009d\u2019\u00bb",
4698 Fscr : "\u00e2\u201e\u00b1",
4699 gacute : "\u00c7\u00b5",
4700 Gamma : "\u00ce\u201c",
4701 gamma : "\u00ce\u00b3",
4702 Gammad : "\u00cf\u0153",
4703 gammad : "\u00cf\u009d",
4704 gap : "\u00e2\u00aa\u2020",
4705 Gbreve : "\u00c4\u017e",
4706 gbreve : "\u00c4\u0178",
4707 Gcedil : "\u00c4\u00a2",
4708 Gcirc : "\u00c4\u0153",
4709 gcirc : "\u00c4\u009d",
4710 Gcy : "\u00d0\u201c",
4711 gcy : "\u00d0\u00b3",
4712 Gdot : "\u00c4 ",
4713 gdot : "\u00c4\u00a1",
4714 ge : "\u00e2\u2030\u00a5",
4715 gE : "\u00e2\u2030\u00a7",
4716 gEl : "\u00e2\u00aa\u0152",
4717 gel : "\u00e2\u2039\u203a",
4718 geq : "\u00e2\u2030\u00a5",
4719 geqq : "\u00e2\u2030\u00a7",
4720 geqslant : "\u00e2\u00a9\u00be",
4721 gescc : "\u00e2\u00aa\u00a9",
4722 ges : "\u00e2\u00a9\u00be",
4723 gesdot : "\u00e2\u00aa\u20ac",
4724 gesdoto : "\u00e2\u00aa\u201a",
4725 gesdotol : "\u00e2\u00aa\u201e",
4726 gesl : "\u00e2\u2039\u203a\u00ef\u00b8\u20ac",
4727 gesles : "\u00e2\u00aa\u201d",
4728 Gfr : "\u00f0\u009d\u201d\u0160",
4729 gfr : "\u00f0\u009d\u201d\u00a4",
4730 gg : "\u00e2\u2030\u00ab",
4731 Gg : "\u00e2\u2039\u2122",
4732 ggg : "\u00e2\u2039\u2122",
4733 gimel : "\u00e2\u201e\u00b7",
4734 GJcy : "\u00d0\u0192",
4735 gjcy : "\u00d1\u201c",
4736 gla : "\u00e2\u00aa\u00a5",
4737 gl : "\u00e2\u2030\u00b7",
4738 glE : "\u00e2\u00aa\u2019",
4739 glj : "\u00e2\u00aa\u00a4",
4740 gnap : "\u00e2\u00aa\u0160",
4741 gnapprox : "\u00e2\u00aa\u0160",
4742 gne : "\u00e2\u00aa\u02c6",
4743 gnE : "\u00e2\u2030\u00a9",
4744 gneq : "\u00e2\u00aa\u02c6",
4745 gneqq : "\u00e2\u2030\u00a9",
4746 gnsim : "\u00e2\u2039\u00a7",
4747 Gopf : "\u00f0\u009d\u201d\u00be",
4748 gopf : "\u00f0\u009d\u2022\u02dc",
4749 grave : "`",
4750 GreaterEqual : "\u00e2\u2030\u00a5",
4751 GreaterEqualLess : "\u00e2\u2039\u203a",
4752 GreaterFullEqual : "\u00e2\u2030\u00a7",
4753 GreaterGreater : "\u00e2\u00aa\u00a2",
4754 GreaterLess : "\u00e2\u2030\u00b7",
4755 GreaterSlantEqual : "\u00e2\u00a9\u00be",
4756 GreaterTilde : "\u00e2\u2030\u00b3",
4757 Gscr : "\u00f0\u009d\u2019\u00a2",
4758 gscr : "\u00e2\u201e\u0160",
4759 gsim : "\u00e2\u2030\u00b3",
4760 gsime : "\u00e2\u00aa\u017d",
4761 gsiml : "\u00e2\u00aa\u0090",
4762 gtcc : "\u00e2\u00aa\u00a7",
4763 gtcir : "\u00e2\u00a9\u00ba",
4764 gt : ">",
4765 GT : ">",
4766 Gt : "\u00e2\u2030\u00ab",
4767 gtdot : "\u00e2\u2039\u2014",
4768 gtlPar : "\u00e2\u00a6\u2022",
4769 gtquest : "\u00e2\u00a9\u00bc",
4770 gtrapprox : "\u00e2\u00aa\u2020",
4771 gtrarr : "\u00e2\u00a5\u00b8",
4772 gtrdot : "\u00e2\u2039\u2014",
4773 gtreqless : "\u00e2\u2039\u203a",
4774 gtreqqless : "\u00e2\u00aa\u0152",
4775 gtrless : "\u00e2\u2030\u00b7",
4776 gtrsim : "\u00e2\u2030\u00b3",
4777 gvertneqq : "\u00e2\u2030\u00a9\u00ef\u00b8\u20ac",
4778 gvnE : "\u00e2\u2030\u00a9\u00ef\u00b8\u20ac",
4779 Hacek : "\u00cb\u2021",
4780 hairsp : "\u00e2\u20ac\u0160",
4781 half : "\u00c2\u00bd",
4782 hamilt : "\u00e2\u201e\u2039",
4783 HARDcy : "\u00d0\u00aa",
4784 hardcy : "\u00d1\u0160",
4785 harrcir : "\u00e2\u00a5\u02c6",
4786 harr : "\u00e2\u2020\u201d",
4787 hArr : "\u00e2\u2021\u201d",
4788 harrw : "\u00e2\u2020\u00ad",
4789 Hat : "^",
4790 hbar : "\u00e2\u201e\u008f",
4791 Hcirc : "\u00c4\u00a4",
4792 hcirc : "\u00c4\u00a5",
4793 hearts : "\u00e2\u2122\u00a5",
4794 heartsuit : "\u00e2\u2122\u00a5",
4795 hellip : "\u00e2\u20ac\u00a6",
4796 hercon : "\u00e2\u0160\u00b9",
4797 hfr : "\u00f0\u009d\u201d\u00a5",
4798 Hfr : "\u00e2\u201e\u0152",
4799 HilbertSpace : "\u00e2\u201e\u2039",
4800 hksearow : "\u00e2\u00a4\u00a5",
4801 hkswarow : "\u00e2\u00a4\u00a6",
4802 hoarr : "\u00e2\u2021\u00bf",
4803 homtht : "\u00e2\u02c6\u00bb",
4804 hookleftarrow : "\u00e2\u2020\u00a9",
4805 hookrightarrow : "\u00e2\u2020\u00aa",
4806 hopf : "\u00f0\u009d\u2022\u2122",
4807 Hopf : "\u00e2\u201e\u008d",
4808 horbar : "\u00e2\u20ac\u2022",
4809 HorizontalLine : "\u00e2\u201d\u20ac",
4810 hscr : "\u00f0\u009d\u2019\u00bd",
4811 Hscr : "\u00e2\u201e\u2039",
4812 hslash : "\u00e2\u201e\u008f",
4813 Hstrok : "\u00c4\u00a6",
4814 hstrok : "\u00c4\u00a7",
4815 HumpDownHump : "\u00e2\u2030\u017d",
4816 HumpEqual : "\u00e2\u2030\u008f",
4817 hybull : "\u00e2\u0081\u0192",
4818 hyphen : "\u00e2\u20ac\u0090",
4819 Iacute : "\u00c3\u008d",
4820 iacute : "\u00c3\u00ad",
4821 ic : "\u00e2\u0081\u00a3",
4822 Icirc : "\u00c3\u017d",
4823 icirc : "\u00c3\u00ae",
4824 Icy : "\u00d0\u02dc",
4825 icy : "\u00d0\u00b8",
4826 Idot : "\u00c4\u00b0",
4827 IEcy : "\u00d0\u2022",
4828 iecy : "\u00d0\u00b5",
4829 iexcl : "\u00c2\u00a1",
4830 iff : "\u00e2\u2021\u201d",
4831 ifr : "\u00f0\u009d\u201d\u00a6",
4832 Ifr : "\u00e2\u201e\u2018",
4833 Igrave : "\u00c3\u0152",
4834 igrave : "\u00c3\u00ac",
4835 ii : "\u00e2\u2026\u02c6",
4836 iiiint : "\u00e2\u00a8\u0152",
4837 iiint : "\u00e2\u02c6\u00ad",
4838 iinfin : "\u00e2\u00a7\u0153",
4839 iiota : "\u00e2\u201e\u00a9",
4840 IJlig : "\u00c4\u00b2",
4841 ijlig : "\u00c4\u00b3",
4842 Imacr : "\u00c4\u00aa",
4843 imacr : "\u00c4\u00ab",
4844 image : "\u00e2\u201e\u2018",
4845 ImaginaryI : "\u00e2\u2026\u02c6",
4846 imagline : "\u00e2\u201e\u0090",
4847 imagpart : "\u00e2\u201e\u2018",
4848 imath : "\u00c4\u00b1",
4849 Im : "\u00e2\u201e\u2018",
4850 imof : "\u00e2\u0160\u00b7",
4851 imped : "\u00c6\u00b5",
4852 Implies : "\u00e2\u2021\u2019",
4853 incare : "\u00e2\u201e\u2026",
4854 "in" : "\u00e2\u02c6\u02c6",
4855 infin : "\u00e2\u02c6\u017e",
4856 infintie : "\u00e2\u00a7\u009d",
4857 inodot : "\u00c4\u00b1",
4858 intcal : "\u00e2\u0160\u00ba",
4859 int : "\u00e2\u02c6\u00ab",
4860 Int : "\u00e2\u02c6\u00ac",
4861 integers : "\u00e2\u201e\u00a4",
4862 Integral : "\u00e2\u02c6\u00ab",
4863 intercal : "\u00e2\u0160\u00ba",
4864 Intersection : "\u00e2\u2039\u201a",
4865 intlarhk : "\u00e2\u00a8\u2014",
4866 intprod : "\u00e2\u00a8\u00bc",
4867 InvisibleComma : "\u00e2\u0081\u00a3",
4868 InvisibleTimes : "\u00e2\u0081\u00a2",
4869 IOcy : "\u00d0\u0081",
4870 iocy : "\u00d1\u2018",
4871 Iogon : "\u00c4\u00ae",
4872 iogon : "\u00c4\u00af",
4873 Iopf : "\u00f0\u009d\u2022\u20ac",
4874 iopf : "\u00f0\u009d\u2022\u0161",
4875 Iota : "\u00ce\u2122",
4876 iota : "\u00ce\u00b9",
4877 iprod : "\u00e2\u00a8\u00bc",
4878 iquest : "\u00c2\u00bf",
4879 iscr : "\u00f0\u009d\u2019\u00be",
4880 Iscr : "\u00e2\u201e\u0090",
4881 isin : "\u00e2\u02c6\u02c6",
4882 isindot : "\u00e2\u2039\u00b5",
4883 isinE : "\u00e2\u2039\u00b9",
4884 isins : "\u00e2\u2039\u00b4",
4885 isinsv : "\u00e2\u2039\u00b3",
4886 isinv : "\u00e2\u02c6\u02c6",
4887 it : "\u00e2\u0081\u00a2",
4888 Itilde : "\u00c4\u00a8",
4889 itilde : "\u00c4\u00a9",
4890 Iukcy : "\u00d0\u2020",
4891 iukcy : "\u00d1\u2013",
4892 Iuml : "\u00c3\u008f",
4893 iuml : "\u00c3\u00af",
4894 Jcirc : "\u00c4\u00b4",
4895 jcirc : "\u00c4\u00b5",
4896 Jcy : "\u00d0\u2122",
4897 jcy : "\u00d0\u00b9",
4898 Jfr : "\u00f0\u009d\u201d\u008d",
4899 jfr : "\u00f0\u009d\u201d\u00a7",
4900 jmath : "\u00c8\u00b7",
4901 Jopf : "\u00f0\u009d\u2022\u0081",
4902 jopf : "\u00f0\u009d\u2022\u203a",
4903 Jscr : "\u00f0\u009d\u2019\u00a5",
4904 jscr : "\u00f0\u009d\u2019\u00bf",
4905 Jsercy : "\u00d0\u02c6",
4906 jsercy : "\u00d1\u02dc",
4907 Jukcy : "\u00d0\u201e",
4908 jukcy : "\u00d1\u201d",
4909 Kappa : "\u00ce\u0161",
4910 kappa : "\u00ce\u00ba",
4911 kappav : "\u00cf\u00b0",
4912 Kcedil : "\u00c4\u00b6",
4913 kcedil : "\u00c4\u00b7",
4914 Kcy : "\u00d0\u0161",
4915 kcy : "\u00d0\u00ba",
4916 Kfr : "\u00f0\u009d\u201d\u017d",
4917 kfr : "\u00f0\u009d\u201d\u00a8",
4918 kgreen : "\u00c4\u00b8",
4919 KHcy : "\u00d0\u00a5",
4920 khcy : "\u00d1\u2026",
4921 KJcy : "\u00d0\u0152",
4922 kjcy : "\u00d1\u0153",
4923 Kopf : "\u00f0\u009d\u2022\u201a",
4924 kopf : "\u00f0\u009d\u2022\u0153",
4925 Kscr : "\u00f0\u009d\u2019\u00a6",
4926 kscr : "\u00f0\u009d\u201c\u20ac",
4927 lAarr : "\u00e2\u2021\u0161",
4928 Lacute : "\u00c4\u00b9",
4929 lacute : "\u00c4\u00ba",
4930 laemptyv : "\u00e2\u00a6\u00b4",
4931 lagran : "\u00e2\u201e\u2019",
4932 Lambda : "\u00ce\u203a",
4933 lambda : "\u00ce\u00bb",
4934 lang : "\u00e2\u0178\u00a8",
4935 Lang : "\u00e2\u0178\u00aa",
4936 langd : "\u00e2\u00a6\u2018",
4937 langle : "\u00e2\u0178\u00a8",
4938 lap : "\u00e2\u00aa\u2026",
4939 Laplacetrf : "\u00e2\u201e\u2019",
4940 laquo : "\u00c2\u00ab",
4941 larrb : "\u00e2\u2021\u00a4",
4942 larrbfs : "\u00e2\u00a4\u0178",
4943 larr : "\u00e2\u2020\u0090",
4944 Larr : "\u00e2\u2020\u017e",
4945 lArr : "\u00e2\u2021\u0090",
4946 larrfs : "\u00e2\u00a4\u009d",
4947 larrhk : "\u00e2\u2020\u00a9",
4948 larrlp : "\u00e2\u2020\u00ab",
4949 larrpl : "\u00e2\u00a4\u00b9",
4950 larrsim : "\u00e2\u00a5\u00b3",
4951 larrtl : "\u00e2\u2020\u00a2",
4952 latail : "\u00e2\u00a4\u2122",
4953 lAtail : "\u00e2\u00a4\u203a",
4954 lat : "\u00e2\u00aa\u00ab",
4955 late : "\u00e2\u00aa\u00ad",
4956 lates : "\u00e2\u00aa\u00ad\u00ef\u00b8\u20ac",
4957 lbarr : "\u00e2\u00a4\u0152",
4958 lBarr : "\u00e2\u00a4\u017d",
4959 lbbrk : "\u00e2\u009d\u00b2",
4960 lbrace : "{",
4961 lbrack : "[",
4962 lbrke : "\u00e2\u00a6\u2039",
4963 lbrksld : "\u00e2\u00a6\u008f",
4964 lbrkslu : "\u00e2\u00a6\u008d",
4965 Lcaron : "\u00c4\u00bd",
4966 lcaron : "\u00c4\u00be",
4967 Lcedil : "\u00c4\u00bb",
4968 lcedil : "\u00c4\u00bc",
4969 lceil : "\u00e2\u0152\u02c6",
4970 lcub : "{",
4971 Lcy : "\u00d0\u203a",
4972 lcy : "\u00d0\u00bb",
4973 ldca : "\u00e2\u00a4\u00b6",
4974 ldquo : "\u00e2\u20ac\u0153",
4975 ldquor : "\u00e2\u20ac\u017e",
4976 ldrdhar : "\u00e2\u00a5\u00a7",
4977 ldrushar : "\u00e2\u00a5\u2039",
4978 ldsh : "\u00e2\u2020\u00b2",
4979 le : "\u00e2\u2030\u00a4",
4980 lE : "\u00e2\u2030\u00a6",
4981 LeftAngleBracket : "\u00e2\u0178\u00a8",
4982 LeftArrowBar : "\u00e2\u2021\u00a4",
4983 leftarrow : "\u00e2\u2020\u0090",
4984 LeftArrow : "\u00e2\u2020\u0090",
4985 Leftarrow : "\u00e2\u2021\u0090",
4986 LeftArrowRightArrow : "\u00e2\u2021\u2020",
4987 leftarrowtail : "\u00e2\u2020\u00a2",
4988 LeftCeiling : "\u00e2\u0152\u02c6",
4989 LeftDoubleBracket : "\u00e2\u0178\u00a6",
4990 LeftDownTeeVector : "\u00e2\u00a5\u00a1",
4991 LeftDownVectorBar : "\u00e2\u00a5\u2122",
4992 LeftDownVector : "\u00e2\u2021\u0192",
4993 LeftFloor : "\u00e2\u0152\u0160",
4994 leftharpoondown : "\u00e2\u2020\u00bd",
4995 leftharpoonup : "\u00e2\u2020\u00bc",
4996 leftleftarrows : "\u00e2\u2021\u2021",
4997 leftrightarrow : "\u00e2\u2020\u201d",
4998 LeftRightArrow : "\u00e2\u2020\u201d",
4999 Leftrightarrow : "\u00e2\u2021\u201d",
5000 leftrightarrows : "\u00e2\u2021\u2020",
5001 leftrightharpoons : "\u00e2\u2021\u2039",
5002 leftrightsquigarrow : "\u00e2\u2020\u00ad",
5003 LeftRightVector : "\u00e2\u00a5\u017d",
5004 LeftTeeArrow : "\u00e2\u2020\u00a4",
5005 LeftTee : "\u00e2\u0160\u00a3",
5006 LeftTeeVector : "\u00e2\u00a5\u0161",
5007 leftthreetimes : "\u00e2\u2039\u2039",
5008 LeftTriangleBar : "\u00e2\u00a7\u008f",
5009 LeftTriangle : "\u00e2\u0160\u00b2",
5010 LeftTriangleEqual : "\u00e2\u0160\u00b4",
5011 LeftUpDownVector : "\u00e2\u00a5\u2018",
5012 LeftUpTeeVector : "\u00e2\u00a5 ",
5013 LeftUpVectorBar : "\u00e2\u00a5\u02dc",
5014 LeftUpVector : "\u00e2\u2020\u00bf",
5015 LeftVectorBar : "\u00e2\u00a5\u2019",
5016 LeftVector : "\u00e2\u2020\u00bc",
5017 lEg : "\u00e2\u00aa\u2039",
5018 leg : "\u00e2\u2039\u0161",
5019 leq : "\u00e2\u2030\u00a4",
5020 leqq : "\u00e2\u2030\u00a6",
5021 leqslant : "\u00e2\u00a9\u00bd",
5022 lescc : "\u00e2\u00aa\u00a8",
5023 les : "\u00e2\u00a9\u00bd",
5024 lesdot : "\u00e2\u00a9\u00bf",
5025 lesdoto : "\u00e2\u00aa\u0081",
5026 lesdotor : "\u00e2\u00aa\u0192",
5027 lesg : "\u00e2\u2039\u0161\u00ef\u00b8\u20ac",
5028 lesges : "\u00e2\u00aa\u201c",
5029 lessapprox : "\u00e2\u00aa\u2026",
5030 lessdot : "\u00e2\u2039\u2013",
5031 lesseqgtr : "\u00e2\u2039\u0161",
5032 lesseqqgtr : "\u00e2\u00aa\u2039",
5033 LessEqualGreater : "\u00e2\u2039\u0161",
5034 LessFullEqual : "\u00e2\u2030\u00a6",
5035 LessGreater : "\u00e2\u2030\u00b6",
5036 lessgtr : "\u00e2\u2030\u00b6",
5037 LessLess : "\u00e2\u00aa\u00a1",
5038 lesssim : "\u00e2\u2030\u00b2",
5039 LessSlantEqual : "\u00e2\u00a9\u00bd",
5040 LessTilde : "\u00e2\u2030\u00b2",
5041 lfisht : "\u00e2\u00a5\u00bc",
5042 lfloor : "\u00e2\u0152\u0160",
5043 Lfr : "\u00f0\u009d\u201d\u008f",
5044 lfr : "\u00f0\u009d\u201d\u00a9",
5045 lg : "\u00e2\u2030\u00b6",
5046 lgE : "\u00e2\u00aa\u2018",
5047 lHar : "\u00e2\u00a5\u00a2",
5048 lhard : "\u00e2\u2020\u00bd",
5049 lharu : "\u00e2\u2020\u00bc",
5050 lharul : "\u00e2\u00a5\u00aa",
5051 lhblk : "\u00e2\u2013\u201e",
5052 LJcy : "\u00d0\u2030",
5053 ljcy : "\u00d1\u2122",
5054 llarr : "\u00e2\u2021\u2021",
5055 ll : "\u00e2\u2030\u00aa",
5056 Ll : "\u00e2\u2039\u02dc",
5057 llcorner : "\u00e2\u0152\u017e",
5058 Lleftarrow : "\u00e2\u2021\u0161",
5059 llhard : "\u00e2\u00a5\u00ab",
5060 lltri : "\u00e2\u2014\u00ba",
5061 Lmidot : "\u00c4\u00bf",
5062 lmidot : "\u00c5\u20ac",
5063 lmoustache : "\u00e2\u017d\u00b0",
5064 lmoust : "\u00e2\u017d\u00b0",
5065 lnap : "\u00e2\u00aa\u2030",
5066 lnapprox : "\u00e2\u00aa\u2030",
5067 lne : "\u00e2\u00aa\u2021",
5068 lnE : "\u00e2\u2030\u00a8",
5069 lneq : "\u00e2\u00aa\u2021",
5070 lneqq : "\u00e2\u2030\u00a8",
5071 lnsim : "\u00e2\u2039\u00a6",
5072 loang : "\u00e2\u0178\u00ac",
5073 loarr : "\u00e2\u2021\u00bd",
5074 lobrk : "\u00e2\u0178\u00a6",
5075 longleftarrow : "\u00e2\u0178\u00b5",
5076 LongLeftArrow : "\u00e2\u0178\u00b5",
5077 Longleftarrow : "\u00e2\u0178\u00b8",
5078 longleftrightarrow : "\u00e2\u0178\u00b7",
5079 LongLeftRightArrow : "\u00e2\u0178\u00b7",
5080 Longleftrightarrow : "\u00e2\u0178\u00ba",
5081 longmapsto : "\u00e2\u0178\u00bc",
5082 longrightarrow : "\u00e2\u0178\u00b6",
5083 LongRightArrow : "\u00e2\u0178\u00b6",
5084 Longrightarrow : "\u00e2\u0178\u00b9",
5085 looparrowleft : "\u00e2\u2020\u00ab",
5086 looparrowright : "\u00e2\u2020\u00ac",
5087 lopar : "\u00e2\u00a6\u2026",
5088 Lopf : "\u00f0\u009d\u2022\u0192",
5089 lopf : "\u00f0\u009d\u2022\u009d",
5090 loplus : "\u00e2\u00a8\u00ad",
5091 lotimes : "\u00e2\u00a8\u00b4",
5092 lowast : "\u00e2\u02c6\u2014",
5093 lowbar : "_",
5094 LowerLeftArrow : "\u00e2\u2020\u2122",
5095 LowerRightArrow : "\u00e2\u2020\u02dc",
5096 loz : "\u00e2\u2014\u0160",
5097 lozenge : "\u00e2\u2014\u0160",
5098 lozf : "\u00e2\u00a7\u00ab",
5099 lpar : "(",
5100 lparlt : "\u00e2\u00a6\u201c",
5101 lrarr : "\u00e2\u2021\u2020",
5102 lrcorner : "\u00e2\u0152\u0178",
5103 lrhar : "\u00e2\u2021\u2039",
5104 lrhard : "\u00e2\u00a5\u00ad",
5105 lrm : "\u00e2\u20ac\u017d",
5106 lrtri : "\u00e2\u0160\u00bf",
5107 lsaquo : "\u00e2\u20ac\u00b9",
5108 lscr : "\u00f0\u009d\u201c\u0081",
5109 Lscr : "\u00e2\u201e\u2019",
5110 lsh : "\u00e2\u2020\u00b0",
5111 Lsh : "\u00e2\u2020\u00b0",
5112 lsim : "\u00e2\u2030\u00b2",
5113 lsime : "\u00e2\u00aa\u008d",
5114 lsimg : "\u00e2\u00aa\u008f",
5115 lsqb : "[",
5116 lsquo : "\u00e2\u20ac\u02dc",
5117 lsquor : "\u00e2\u20ac\u0161",
5118 Lstrok : "\u00c5\u0081",
5119 lstrok : "\u00c5\u201a",
5120 ltcc : "\u00e2\u00aa\u00a6",
5121 ltcir : "\u00e2\u00a9\u00b9",
5122 lt : "<",
5123 LT : "<",
5124 Lt : "\u00e2\u2030\u00aa",
5125 ltdot : "\u00e2\u2039\u2013",
5126 lthree : "\u00e2\u2039\u2039",
5127 ltimes : "\u00e2\u2039\u2030",
5128 ltlarr : "\u00e2\u00a5\u00b6",
5129 ltquest : "\u00e2\u00a9\u00bb",
5130 ltri : "\u00e2\u2014\u0192",
5131 ltrie : "\u00e2\u0160\u00b4",
5132 ltrif : "\u00e2\u2014\u201a",
5133 ltrPar : "\u00e2\u00a6\u2013",
5134 lurdshar : "\u00e2\u00a5\u0160",
5135 luruhar : "\u00e2\u00a5\u00a6",
5136 lvertneqq : "\u00e2\u2030\u00a8\u00ef\u00b8\u20ac",
5137 lvnE : "\u00e2\u2030\u00a8\u00ef\u00b8\u20ac",
5138 macr : "\u00c2\u00af",
5139 male : "\u00e2\u2122\u201a",
5140 malt : "\u00e2\u0153 ",
5141 maltese : "\u00e2\u0153 ",
5142 Map : "\u00e2\u00a4\u2026",
5143 map : "\u00e2\u2020\u00a6",
5144 mapsto : "\u00e2\u2020\u00a6",
5145 mapstodown : "\u00e2\u2020\u00a7",
5146 mapstoleft : "\u00e2\u2020\u00a4",
5147 mapstoup : "\u00e2\u2020\u00a5",
5148 marker : "\u00e2\u2013\u00ae",
5149 mcomma : "\u00e2\u00a8\u00a9",
5150 Mcy : "\u00d0\u0153",
5151 mcy : "\u00d0\u00bc",
5152 mdash : "\u00e2\u20ac\u201d",
5153 mDDot : "\u00e2\u02c6\u00ba",
5154 measuredangle : "\u00e2\u02c6\u00a1",
5155 MediumSpace : "\u00e2\u0081\u0178",
5156 Mellintrf : "\u00e2\u201e\u00b3",
5157 Mfr : "\u00f0\u009d\u201d\u0090",
5158 mfr : "\u00f0\u009d\u201d\u00aa",
5159 mho : "\u00e2\u201e\u00a7",
5160 micro : "\u00c2\u00b5",
5161 midast : "*",
5162 midcir : "\u00e2\u00ab\u00b0",
5163 mid : "\u00e2\u02c6\u00a3",
5164 middot : "\u00c2\u00b7",
5165 minusb : "\u00e2\u0160\u0178",
5166 minus : "\u00e2\u02c6\u2019",
5167 minusd : "\u00e2\u02c6\u00b8",
5168 minusdu : "\u00e2\u00a8\u00aa",
5169 MinusPlus : "\u00e2\u02c6\u201c",
5170 mlcp : "\u00e2\u00ab\u203a",
5171 mldr : "\u00e2\u20ac\u00a6",
5172 mnplus : "\u00e2\u02c6\u201c",
5173 models : "\u00e2\u0160\u00a7",
5174 Mopf : "\u00f0\u009d\u2022\u201e",
5175 mopf : "\u00f0\u009d\u2022\u017e",
5176 mp : "\u00e2\u02c6\u201c",
5177 mscr : "\u00f0\u009d\u201c\u201a",
5178 Mscr : "\u00e2\u201e\u00b3",
5179 mstpos : "\u00e2\u02c6\u00be",
5180 Mu : "\u00ce\u0153",
5181 mu : "\u00ce\u00bc",
5182 multimap : "\u00e2\u0160\u00b8",
5183 mumap : "\u00e2\u0160\u00b8",
5184 nabla : "\u00e2\u02c6\u2021",
5185 Nacute : "\u00c5\u0192",
5186 nacute : "\u00c5\u201e",
5187 nang : "\u00e2\u02c6 \u00e2\u0192\u2019",
5188 nap : "\u00e2\u2030\u2030",
5189 napE : "\u00e2\u00a9\u00b0\u00cc\u00b8",
5190 napid : "\u00e2\u2030\u2039\u00cc\u00b8",
5191 napos : "\u00c5\u2030",
5192 napprox : "\u00e2\u2030\u2030",
5193 natural : "\u00e2\u2122\u00ae",
5194 naturals : "\u00e2\u201e\u2022",
5195 natur : "\u00e2\u2122\u00ae",
5196 nbsp : "\u00c2 ",
5197 nbump : "\u00e2\u2030\u017d\u00cc\u00b8",
5198 nbumpe : "\u00e2\u2030\u008f\u00cc\u00b8",
5199 ncap : "\u00e2\u00a9\u0192",
5200 Ncaron : "\u00c5\u2021",
5201 ncaron : "\u00c5\u02c6",
5202 Ncedil : "\u00c5\u2026",
5203 ncedil : "\u00c5\u2020",
5204 ncong : "\u00e2\u2030\u2021",
5205 ncongdot : "\u00e2\u00a9\u00ad\u00cc\u00b8",
5206 ncup : "\u00e2\u00a9\u201a",
5207 Ncy : "\u00d0\u009d",
5208 ncy : "\u00d0\u00bd",
5209 ndash : "\u00e2\u20ac\u201c",
5210 nearhk : "\u00e2\u00a4\u00a4",
5211 nearr : "\u00e2\u2020\u2014",
5212 neArr : "\u00e2\u2021\u2014",
5213 nearrow : "\u00e2\u2020\u2014",
5214 ne : "\u00e2\u2030 ",
5215 nedot : "\u00e2\u2030\u0090\u00cc\u00b8",
5216 NegativeMediumSpace : "\u00e2\u20ac\u2039",
5217 NegativeThickSpace : "\u00e2\u20ac\u2039",
5218 NegativeThinSpace : "\u00e2\u20ac\u2039",
5219 NegativeVeryThinSpace : "\u00e2\u20ac\u2039",
5220 nequiv : "\u00e2\u2030\u00a2",
5221 nesear : "\u00e2\u00a4\u00a8",
5222 nesim : "\u00e2\u2030\u201a\u00cc\u00b8",
5223 NestedGreaterGreater : "\u00e2\u2030\u00ab",
5224 NestedLessLess : "\u00e2\u2030\u00aa",
5225 NewLine : "\n",
5226 nexist : "\u00e2\u02c6\u201e",
5227 nexists : "\u00e2\u02c6\u201e",
5228 Nfr : "\u00f0\u009d\u201d\u2018",
5229 nfr : "\u00f0\u009d\u201d\u00ab",
5230 ngE : "\u00e2\u2030\u00a7\u00cc\u00b8",
5231 nge : "\u00e2\u2030\u00b1",
5232 ngeq : "\u00e2\u2030\u00b1",
5233 ngeqq : "\u00e2\u2030\u00a7\u00cc\u00b8",
5234 ngeqslant : "\u00e2\u00a9\u00be\u00cc\u00b8",
5235 nges : "\u00e2\u00a9\u00be\u00cc\u00b8",
5236 nGg : "\u00e2\u2039\u2122\u00cc\u00b8",
5237 ngsim : "\u00e2\u2030\u00b5",
5238 nGt : "\u00e2\u2030\u00ab\u00e2\u0192\u2019",
5239 ngt : "\u00e2\u2030\u00af",
5240 ngtr : "\u00e2\u2030\u00af",
5241 nGtv : "\u00e2\u2030\u00ab\u00cc\u00b8",
5242 nharr : "\u00e2\u2020\u00ae",
5243 nhArr : "\u00e2\u2021\u017d",
5244 nhpar : "\u00e2\u00ab\u00b2",
5245 ni : "\u00e2\u02c6\u2039",
5246 nis : "\u00e2\u2039\u00bc",
5247 nisd : "\u00e2\u2039\u00ba",
5248 niv : "\u00e2\u02c6\u2039",
5249 NJcy : "\u00d0\u0160",
5250 njcy : "\u00d1\u0161",
5251 nlarr : "\u00e2\u2020\u0161",
5252 nlArr : "\u00e2\u2021\u008d",
5253 nldr : "\u00e2\u20ac\u00a5",
5254 nlE : "\u00e2\u2030\u00a6\u00cc\u00b8",
5255 nle : "\u00e2\u2030\u00b0",
5256 nleftarrow : "\u00e2\u2020\u0161",
5257 nLeftarrow : "\u00e2\u2021\u008d",
5258 nleftrightarrow : "\u00e2\u2020\u00ae",
5259 nLeftrightarrow : "\u00e2\u2021\u017d",
5260 nleq : "\u00e2\u2030\u00b0",
5261 nleqq : "\u00e2\u2030\u00a6\u00cc\u00b8",
5262 nleqslant : "\u00e2\u00a9\u00bd\u00cc\u00b8",
5263 nles : "\u00e2\u00a9\u00bd\u00cc\u00b8",
5264 nless : "\u00e2\u2030\u00ae",
5265 nLl : "\u00e2\u2039\u02dc\u00cc\u00b8",
5266 nlsim : "\u00e2\u2030\u00b4",
5267 nLt : "\u00e2\u2030\u00aa\u00e2\u0192\u2019",
5268 nlt : "\u00e2\u2030\u00ae",
5269 nltri : "\u00e2\u2039\u00aa",
5270 nltrie : "\u00e2\u2039\u00ac",
5271 nLtv : "\u00e2\u2030\u00aa\u00cc\u00b8",
5272 nmid : "\u00e2\u02c6\u00a4",
5273 NoBreak : "\u00e2\u0081 ",
5274 NonBreakingSpace : "\u00c2 ",
5275 nopf : "\u00f0\u009d\u2022\u0178",
5276 Nopf : "\u00e2\u201e\u2022",
5277 Not : "\u00e2\u00ab\u00ac",
5278 not : "\u00c2\u00ac",
5279 NotCongruent : "\u00e2\u2030\u00a2",
5280 NotCupCap : "\u00e2\u2030\u00ad",
5281 NotDoubleVerticalBar : "\u00e2\u02c6\u00a6",
5282 NotElement : "\u00e2\u02c6\u2030",
5283 NotEqual : "\u00e2\u2030 ",
5284 NotEqualTilde : "\u00e2\u2030\u201a\u00cc\u00b8",
5285 NotExists : "\u00e2\u02c6\u201e",
5286 NotGreater : "\u00e2\u2030\u00af",
5287 NotGreaterEqual : "\u00e2\u2030\u00b1",
5288 NotGreaterFullEqual : "\u00e2\u2030\u00a7\u00cc\u00b8",
5289 NotGreaterGreater : "\u00e2\u2030\u00ab\u00cc\u00b8",
5290 NotGreaterLess : "\u00e2\u2030\u00b9",
5291 NotGreaterSlantEqual : "\u00e2\u00a9\u00be\u00cc\u00b8",
5292 NotGreaterTilde : "\u00e2\u2030\u00b5",
5293 NotHumpDownHump : "\u00e2\u2030\u017d\u00cc\u00b8",
5294 NotHumpEqual : "\u00e2\u2030\u008f\u00cc\u00b8",
5295 notin : "\u00e2\u02c6\u2030",
5296 notindot : "\u00e2\u2039\u00b5\u00cc\u00b8",
5297 notinE : "\u00e2\u2039\u00b9\u00cc\u00b8",
5298 notinva : "\u00e2\u02c6\u2030",
5299 notinvb : "\u00e2\u2039\u00b7",
5300 notinvc : "\u00e2\u2039\u00b6",
5301 NotLeftTriangleBar : "\u00e2\u00a7\u008f\u00cc\u00b8",
5302 NotLeftTriangle : "\u00e2\u2039\u00aa",
5303 NotLeftTriangleEqual : "\u00e2\u2039\u00ac",
5304 NotLess : "\u00e2\u2030\u00ae",
5305 NotLessEqual : "\u00e2\u2030\u00b0",
5306 NotLessGreater : "\u00e2\u2030\u00b8",
5307 NotLessLess : "\u00e2\u2030\u00aa\u00cc\u00b8",
5308 NotLessSlantEqual : "\u00e2\u00a9\u00bd\u00cc\u00b8",
5309 NotLessTilde : "\u00e2\u2030\u00b4",
5310 NotNestedGreaterGreater : "\u00e2\u00aa\u00a2\u00cc\u00b8",
5311 NotNestedLessLess : "\u00e2\u00aa\u00a1\u00cc\u00b8",
5312 notni : "\u00e2\u02c6\u0152",
5313 notniva : "\u00e2\u02c6\u0152",
5314 notnivb : "\u00e2\u2039\u00be",
5315 notnivc : "\u00e2\u2039\u00bd",
5316 NotPrecedes : "\u00e2\u0160\u20ac",
5317 NotPrecedesEqual : "\u00e2\u00aa\u00af\u00cc\u00b8",
5318 NotPrecedesSlantEqual : "\u00e2\u2039 ",
5319 NotReverseElement : "\u00e2\u02c6\u0152",
5320 NotRightTriangleBar : "\u00e2\u00a7\u0090\u00cc\u00b8",
5321 NotRightTriangle : "\u00e2\u2039\u00ab",
5322 NotRightTriangleEqual : "\u00e2\u2039\u00ad",
5323 NotSquareSubset : "\u00e2\u0160\u008f\u00cc\u00b8",
5324 NotSquareSubsetEqual : "\u00e2\u2039\u00a2",
5325 NotSquareSuperset : "\u00e2\u0160\u0090\u00cc\u00b8",
5326 NotSquareSupersetEqual : "\u00e2\u2039\u00a3",
5327 NotSubset : "\u00e2\u0160\u201a\u00e2\u0192\u2019",
5328 NotSubsetEqual : "\u00e2\u0160\u02c6",
5329 NotSucceeds : "\u00e2\u0160\u0081",
5330 NotSucceedsEqual : "\u00e2\u00aa\u00b0\u00cc\u00b8",
5331 NotSucceedsSlantEqual : "\u00e2\u2039\u00a1",
5332 NotSucceedsTilde : "\u00e2\u2030\u00bf\u00cc\u00b8",
5333 NotSuperset : "\u00e2\u0160\u0192\u00e2\u0192\u2019",
5334 NotSupersetEqual : "\u00e2\u0160\u2030",
5335 NotTilde : "\u00e2\u2030\u0081",
5336 NotTildeEqual : "\u00e2\u2030\u201e",
5337 NotTildeFullEqual : "\u00e2\u2030\u2021",
5338 NotTildeTilde : "\u00e2\u2030\u2030",
5339 NotVerticalBar : "\u00e2\u02c6\u00a4",
5340 nparallel : "\u00e2\u02c6\u00a6",
5341 npar : "\u00e2\u02c6\u00a6",
5342 nparsl : "\u00e2\u00ab\u00bd\u00e2\u0192\u00a5",
5343 npart : "\u00e2\u02c6\u201a\u00cc\u00b8",
5344 npolint : "\u00e2\u00a8\u201d",
5345 npr : "\u00e2\u0160\u20ac",
5346 nprcue : "\u00e2\u2039 ",
5347 nprec : "\u00e2\u0160\u20ac",
5348 npreceq : "\u00e2\u00aa\u00af\u00cc\u00b8",
5349 npre : "\u00e2\u00aa\u00af\u00cc\u00b8",
5350 nrarrc : "\u00e2\u00a4\u00b3\u00cc\u00b8",
5351 nrarr : "\u00e2\u2020\u203a",
5352 nrArr : "\u00e2\u2021\u008f",
5353 nrarrw : "\u00e2\u2020\u009d\u00cc\u00b8",
5354 nrightarrow : "\u00e2\u2020\u203a",
5355 nRightarrow : "\u00e2\u2021\u008f",
5356 nrtri : "\u00e2\u2039\u00ab",
5357 nrtrie : "\u00e2\u2039\u00ad",
5358 nsc : "\u00e2\u0160\u0081",
5359 nsccue : "\u00e2\u2039\u00a1",
5360 nsce : "\u00e2\u00aa\u00b0\u00cc\u00b8",
5361 Nscr : "\u00f0\u009d\u2019\u00a9",
5362 nscr : "\u00f0\u009d\u201c\u0192",
5363 nshortmid : "\u00e2\u02c6\u00a4",
5364 nshortparallel : "\u00e2\u02c6\u00a6",
5365 nsim : "\u00e2\u2030\u0081",
5366 nsime : "\u00e2\u2030\u201e",
5367 nsimeq : "\u00e2\u2030\u201e",
5368 nsmid : "\u00e2\u02c6\u00a4",
5369 nspar : "\u00e2\u02c6\u00a6",
5370 nsqsube : "\u00e2\u2039\u00a2",
5371 nsqsupe : "\u00e2\u2039\u00a3",
5372 nsub : "\u00e2\u0160\u201e",
5373 nsubE : "\u00e2\u00ab\u2026\u00cc\u00b8",
5374 nsube : "\u00e2\u0160\u02c6",
5375 nsubset : "\u00e2\u0160\u201a\u00e2\u0192\u2019",
5376 nsubseteq : "\u00e2\u0160\u02c6",
5377 nsubseteqq : "\u00e2\u00ab\u2026\u00cc\u00b8",
5378 nsucc : "\u00e2\u0160\u0081",
5379 nsucceq : "\u00e2\u00aa\u00b0\u00cc\u00b8",
5380 nsup : "\u00e2\u0160\u2026",
5381 nsupE : "\u00e2\u00ab\u2020\u00cc\u00b8",
5382 nsupe : "\u00e2\u0160\u2030",
5383 nsupset : "\u00e2\u0160\u0192\u00e2\u0192\u2019",
5384 nsupseteq : "\u00e2\u0160\u2030",
5385 nsupseteqq : "\u00e2\u00ab\u2020\u00cc\u00b8",
5386 ntgl : "\u00e2\u2030\u00b9",
5387 Ntilde : "\u00c3\u2018",
5388 ntilde : "\u00c3\u00b1",
5389 ntlg : "\u00e2\u2030\u00b8",
5390 ntriangleleft : "\u00e2\u2039\u00aa",
5391 ntrianglelefteq : "\u00e2\u2039\u00ac",
5392 ntriangleright : "\u00e2\u2039\u00ab",
5393 ntrianglerighteq : "\u00e2\u2039\u00ad",
5394 Nu : "\u00ce\u009d",
5395 nu : "\u00ce\u00bd",
5396 num : "#",
5397 numero : "\u00e2\u201e\u2013",
5398 numsp : "\u00e2\u20ac\u2021",
5399 nvap : "\u00e2\u2030\u008d\u00e2\u0192\u2019",
5400 nvdash : "\u00e2\u0160\u00ac",
5401 nvDash : "\u00e2\u0160\u00ad",
5402 nVdash : "\u00e2\u0160\u00ae",
5403 nVDash : "\u00e2\u0160\u00af",
5404 nvge : "\u00e2\u2030\u00a5\u00e2\u0192\u2019",
5405 nvgt : ">\u00e2\u0192\u2019",
5406 nvHarr : "\u00e2\u00a4\u201e",
5407 nvinfin : "\u00e2\u00a7\u017e",
5408 nvlArr : "\u00e2\u00a4\u201a",
5409 nvle : "\u00e2\u2030\u00a4\u00e2\u0192\u2019",
5410 nvlt : "<\u00e2\u0192\u2019",
5411 nvltrie : "\u00e2\u0160\u00b4\u00e2\u0192\u2019",
5412 nvrArr : "\u00e2\u00a4\u0192",
5413 nvrtrie : "\u00e2\u0160\u00b5\u00e2\u0192\u2019",
5414 nvsim : "\u00e2\u02c6\u00bc\u00e2\u0192\u2019",
5415 nwarhk : "\u00e2\u00a4\u00a3",
5416 nwarr : "\u00e2\u2020\u2013",
5417 nwArr : "\u00e2\u2021\u2013",
5418 nwarrow : "\u00e2\u2020\u2013",
5419 nwnear : "\u00e2\u00a4\u00a7",
5420 Oacute : "\u00c3\u201c",
5421 oacute : "\u00c3\u00b3",
5422 oast : "\u00e2\u0160\u203a",
5423 Ocirc : "\u00c3\u201d",
5424 ocirc : "\u00c3\u00b4",
5425 ocir : "\u00e2\u0160\u0161",
5426 Ocy : "\u00d0\u017e",
5427 ocy : "\u00d0\u00be",
5428 odash : "\u00e2\u0160\u009d",
5429 Odblac : "\u00c5\u0090",
5430 odblac : "\u00c5\u2018",
5431 odiv : "\u00e2\u00a8\u00b8",
5432 odot : "\u00e2\u0160\u2122",
5433 odsold : "\u00e2\u00a6\u00bc",
5434 OElig : "\u00c5\u2019",
5435 oelig : "\u00c5\u201c",
5436 ofcir : "\u00e2\u00a6\u00bf",
5437 Ofr : "\u00f0\u009d\u201d\u2019",
5438 ofr : "\u00f0\u009d\u201d\u00ac",
5439 ogon : "\u00cb\u203a",
5440 Ograve : "\u00c3\u2019",
5441 ograve : "\u00c3\u00b2",
5442 ogt : "\u00e2\u00a7\u0081",
5443 ohbar : "\u00e2\u00a6\u00b5",
5444 ohm : "\u00ce\u00a9",
5445 oint : "\u00e2\u02c6\u00ae",
5446 olarr : "\u00e2\u2020\u00ba",
5447 olcir : "\u00e2\u00a6\u00be",
5448 olcross : "\u00e2\u00a6\u00bb",
5449 oline : "\u00e2\u20ac\u00be",
5450 olt : "\u00e2\u00a7\u20ac",
5451 Omacr : "\u00c5\u0152",
5452 omacr : "\u00c5\u008d",
5453 Omega : "\u00ce\u00a9",
5454 omega : "\u00cf\u2030",
5455 Omicron : "\u00ce\u0178",
5456 omicron : "\u00ce\u00bf",
5457 omid : "\u00e2\u00a6\u00b6",
5458 ominus : "\u00e2\u0160\u2013",
5459 Oopf : "\u00f0\u009d\u2022\u2020",
5460 oopf : "\u00f0\u009d\u2022 ",
5461 opar : "\u00e2\u00a6\u00b7",
5462 OpenCurlyDoubleQuote : "\u00e2\u20ac\u0153",
5463 OpenCurlyQuote : "\u00e2\u20ac\u02dc",
5464 operp : "\u00e2\u00a6\u00b9",
5465 oplus : "\u00e2\u0160\u2022",
5466 orarr : "\u00e2\u2020\u00bb",
5467 Or : "\u00e2\u00a9\u201d",
5468 or : "\u00e2\u02c6\u00a8",
5469 ord : "\u00e2\u00a9\u009d",
5470 order : "\u00e2\u201e\u00b4",
5471 orderof : "\u00e2\u201e\u00b4",
5472 ordf : "\u00c2\u00aa",
5473 ordm : "\u00c2\u00ba",
5474 origof : "\u00e2\u0160\u00b6",
5475 oror : "\u00e2\u00a9\u2013",
5476 orslope : "\u00e2\u00a9\u2014",
5477 orv : "\u00e2\u00a9\u203a",
5478 oS : "\u00e2\u201c\u02c6",
5479 Oscr : "\u00f0\u009d\u2019\u00aa",
5480 oscr : "\u00e2\u201e\u00b4",
5481 Oslash : "\u00c3\u02dc",
5482 oslash : "\u00c3\u00b8",
5483 osol : "\u00e2\u0160\u02dc",
5484 Otilde : "\u00c3\u2022",
5485 otilde : "\u00c3\u00b5",
5486 otimesas : "\u00e2\u00a8\u00b6",
5487 Otimes : "\u00e2\u00a8\u00b7",
5488 otimes : "\u00e2\u0160\u2014",
5489 Ouml : "\u00c3\u2013",
5490 ouml : "\u00c3\u00b6",
5491 ovbar : "\u00e2\u0152\u00bd",
5492 OverBar : "\u00e2\u20ac\u00be",
5493 OverBrace : "\u00e2\u008f\u017e",
5494 OverBracket : "\u00e2\u017d\u00b4",
5495 OverParenthesis : "\u00e2\u008f\u0153",
5496 para : "\u00c2\u00b6",
5497 parallel : "\u00e2\u02c6\u00a5",
5498 par : "\u00e2\u02c6\u00a5",
5499 parsim : "\u00e2\u00ab\u00b3",
5500 parsl : "\u00e2\u00ab\u00bd",
5501 part : "\u00e2\u02c6\u201a",
5502 PartialD : "\u00e2\u02c6\u201a",
5503 Pcy : "\u00d0\u0178",
5504 pcy : "\u00d0\u00bf",
5505 percnt : "%",
5506 period : ".",
5507 permil : "\u00e2\u20ac\u00b0",
5508 perp : "\u00e2\u0160\u00a5",
5509 pertenk : "\u00e2\u20ac\u00b1",
5510 Pfr : "\u00f0\u009d\u201d\u201c",
5511 pfr : "\u00f0\u009d\u201d\u00ad",
5512 Phi : "\u00ce\u00a6",
5513 phi : "\u00cf\u2020",
5514 phiv : "\u00cf\u2022",
5515 phmmat : "\u00e2\u201e\u00b3",
5516 phone : "\u00e2\u02dc\u017d",
5517 Pi : "\u00ce ",
5518 pi : "\u00cf\u20ac",
5519 pitchfork : "\u00e2\u2039\u201d",
5520 piv : "\u00cf\u2013",
5521 planck : "\u00e2\u201e\u008f",
5522 planckh : "\u00e2\u201e\u017d",
5523 plankv : "\u00e2\u201e\u008f",
5524 plusacir : "\u00e2\u00a8\u00a3",
5525 plusb : "\u00e2\u0160\u017e",
5526 pluscir : "\u00e2\u00a8\u00a2",
5527 plus : "+",
5528 plusdo : "\u00e2\u02c6\u201d",
5529 plusdu : "\u00e2\u00a8\u00a5",
5530 pluse : "\u00e2\u00a9\u00b2",
5531 PlusMinus : "\u00c2\u00b1",
5532 plusmn : "\u00c2\u00b1",
5533 plussim : "\u00e2\u00a8\u00a6",
5534 plustwo : "\u00e2\u00a8\u00a7",
5535 pm : "\u00c2\u00b1",
5536 Poincareplane : "\u00e2\u201e\u0152",
5537 pointint : "\u00e2\u00a8\u2022",
5538 popf : "\u00f0\u009d\u2022\u00a1",
5539 Popf : "\u00e2\u201e\u2122",
5540 pound : "\u00c2\u00a3",
5541 prap : "\u00e2\u00aa\u00b7",
5542 Pr : "\u00e2\u00aa\u00bb",
5543 pr : "\u00e2\u2030\u00ba",
5544 prcue : "\u00e2\u2030\u00bc",
5545 precapprox : "\u00e2\u00aa\u00b7",
5546 prec : "\u00e2\u2030\u00ba",
5547 preccurlyeq : "\u00e2\u2030\u00bc",
5548 Precedes : "\u00e2\u2030\u00ba",
5549 PrecedesEqual : "\u00e2\u00aa\u00af",
5550 PrecedesSlantEqual : "\u00e2\u2030\u00bc",
5551 PrecedesTilde : "\u00e2\u2030\u00be",
5552 preceq : "\u00e2\u00aa\u00af",
5553 precnapprox : "\u00e2\u00aa\u00b9",
5554 precneqq : "\u00e2\u00aa\u00b5",
5555 precnsim : "\u00e2\u2039\u00a8",
5556 pre : "\u00e2\u00aa\u00af",
5557 prE : "\u00e2\u00aa\u00b3",
5558 precsim : "\u00e2\u2030\u00be",
5559 prime : "\u00e2\u20ac\u00b2",
5560 Prime : "\u00e2\u20ac\u00b3",
5561 primes : "\u00e2\u201e\u2122",
5562 prnap : "\u00e2\u00aa\u00b9",
5563 prnE : "\u00e2\u00aa\u00b5",
5564 prnsim : "\u00e2\u2039\u00a8",
5565 prod : "\u00e2\u02c6\u008f",
5566 Product : "\u00e2\u02c6\u008f",
5567 profalar : "\u00e2\u0152\u00ae",
5568 profline : "\u00e2\u0152\u2019",
5569 profsurf : "\u00e2\u0152\u201c",
5570 prop : "\u00e2\u02c6\u009d",
5571 Proportional : "\u00e2\u02c6\u009d",
5572 Proportion : "\u00e2\u02c6\u00b7",
5573 propto : "\u00e2\u02c6\u009d",
5574 prsim : "\u00e2\u2030\u00be",
5575 prurel : "\u00e2\u0160\u00b0",
5576 Pscr : "\u00f0\u009d\u2019\u00ab",
5577 pscr : "\u00f0\u009d\u201c\u2026",
5578 Psi : "\u00ce\u00a8",
5579 psi : "\u00cf\u02c6",
5580 puncsp : "\u00e2\u20ac\u02c6",
5581 Qfr : "\u00f0\u009d\u201d\u201d",
5582 qfr : "\u00f0\u009d\u201d\u00ae",
5583 qint : "\u00e2\u00a8\u0152",
5584 qopf : "\u00f0\u009d\u2022\u00a2",
5585 Qopf : "\u00e2\u201e\u0161",
5586 qprime : "\u00e2\u0081\u2014",
5587 Qscr : "\u00f0\u009d\u2019\u00ac",
5588 qscr : "\u00f0\u009d\u201c\u2020",
5589 quaternions : "\u00e2\u201e\u008d",
5590 quatint : "\u00e2\u00a8\u2013",
5591 quest : "?",
5592 questeq : "\u00e2\u2030\u0178",
5593 quot : '"',
5594 QUOT : '"',
5595 rAarr : "\u00e2\u2021\u203a",
5596 race : "\u00e2\u02c6\u00bd\u00cc\u00b1",
5597 Racute : "\u00c5\u201d",
5598 racute : "\u00c5\u2022",
5599 radic : "\u00e2\u02c6\u0161",
5600 raemptyv : "\u00e2\u00a6\u00b3",
5601 rang : "\u00e2\u0178\u00a9",
5602 Rang : "\u00e2\u0178\u00ab",
5603 rangd : "\u00e2\u00a6\u2019",
5604 range : "\u00e2\u00a6\u00a5",
5605 rangle : "\u00e2\u0178\u00a9",
5606 raquo : "\u00c2\u00bb",
5607 rarrap : "\u00e2\u00a5\u00b5",
5608 rarrb : "\u00e2\u2021\u00a5",
5609 rarrbfs : "\u00e2\u00a4 ",
5610 rarrc : "\u00e2\u00a4\u00b3",
5611 rarr : "\u00e2\u2020\u2019",
5612 Rarr : "\u00e2\u2020 ",
5613 rArr : "\u00e2\u2021\u2019",
5614 rarrfs : "\u00e2\u00a4\u017e",
5615 rarrhk : "\u00e2\u2020\u00aa",
5616 rarrlp : "\u00e2\u2020\u00ac",
5617 rarrpl : "\u00e2\u00a5\u2026",
5618 rarrsim : "\u00e2\u00a5\u00b4",
5619 Rarrtl : "\u00e2\u00a4\u2013",
5620 rarrtl : "\u00e2\u2020\u00a3",
5621 rarrw : "\u00e2\u2020\u009d",
5622 ratail : "\u00e2\u00a4\u0161",
5623 rAtail : "\u00e2\u00a4\u0153",
5624 ratio : "\u00e2\u02c6\u00b6",
5625 rationals : "\u00e2\u201e\u0161",
5626 rbarr : "\u00e2\u00a4\u008d",
5627 rBarr : "\u00e2\u00a4\u008f",
5628 RBarr : "\u00e2\u00a4\u0090",
5629 rbbrk : "\u00e2\u009d\u00b3",
5630 rbrace : "}",
5631 rbrack : "]",
5632 rbrke : "\u00e2\u00a6\u0152",
5633 rbrksld : "\u00e2\u00a6\u017d",
5634 rbrkslu : "\u00e2\u00a6\u0090",
5635 Rcaron : "\u00c5\u02dc",
5636 rcaron : "\u00c5\u2122",
5637 Rcedil : "\u00c5\u2013",
5638 rcedil : "\u00c5\u2014",
5639 rceil : "\u00e2\u0152\u2030",
5640 rcub : "}",
5641 Rcy : "\u00d0 ",
5642 rcy : "\u00d1\u20ac",
5643 rdca : "\u00e2\u00a4\u00b7",
5644 rdldhar : "\u00e2\u00a5\u00a9",
5645 rdquo : "\u00e2\u20ac\u009d",
5646 rdquor : "\u00e2\u20ac\u009d",
5647 rdsh : "\u00e2\u2020\u00b3",
5648 real : "\u00e2\u201e\u0153",
5649 realine : "\u00e2\u201e\u203a",
5650 realpart : "\u00e2\u201e\u0153",
5651 reals : "\u00e2\u201e\u009d",
5652 Re : "\u00e2\u201e\u0153",
5653 rect : "\u00e2\u2013\u00ad",
5654 reg : "\u00c2\u00ae",
5655 REG : "\u00c2\u00ae",
5656 ReverseElement : "\u00e2\u02c6\u2039",
5657 ReverseEquilibrium : "\u00e2\u2021\u2039",
5658 ReverseUpEquilibrium : "\u00e2\u00a5\u00af",
5659 rfisht : "\u00e2\u00a5\u00bd",
5660 rfloor : "\u00e2\u0152\u2039",
5661 rfr : "\u00f0\u009d\u201d\u00af",
5662 Rfr : "\u00e2\u201e\u0153",
5663 rHar : "\u00e2\u00a5\u00a4",
5664 rhard : "\u00e2\u2021\u0081",
5665 rharu : "\u00e2\u2021\u20ac",
5666 rharul : "\u00e2\u00a5\u00ac",
5667 Rho : "\u00ce\u00a1",
5668 rho : "\u00cf\u0081",
5669 rhov : "\u00cf\u00b1",
5670 RightAngleBracket : "\u00e2\u0178\u00a9",
5671 RightArrowBar : "\u00e2\u2021\u00a5",
5672 rightarrow : "\u00e2\u2020\u2019",
5673 RightArrow : "\u00e2\u2020\u2019",
5674 Rightarrow : "\u00e2\u2021\u2019",
5675 RightArrowLeftArrow : "\u00e2\u2021\u201e",
5676 rightarrowtail : "\u00e2\u2020\u00a3",
5677 RightCeiling : "\u00e2\u0152\u2030",
5678 RightDoubleBracket : "\u00e2\u0178\u00a7",
5679 RightDownTeeVector : "\u00e2\u00a5\u009d",
5680 RightDownVectorBar : "\u00e2\u00a5\u2022",
5681 RightDownVector : "\u00e2\u2021\u201a",
5682 RightFloor : "\u00e2\u0152\u2039",
5683 rightharpoondown : "\u00e2\u2021\u0081",
5684 rightharpoonup : "\u00e2\u2021\u20ac",
5685 rightleftarrows : "\u00e2\u2021\u201e",
5686 rightleftharpoons : "\u00e2\u2021\u0152",
5687 rightrightarrows : "\u00e2\u2021\u2030",
5688 rightsquigarrow : "\u00e2\u2020\u009d",
5689 RightTeeArrow : "\u00e2\u2020\u00a6",
5690 RightTee : "\u00e2\u0160\u00a2",
5691 RightTeeVector : "\u00e2\u00a5\u203a",
5692 rightthreetimes : "\u00e2\u2039\u0152",
5693 RightTriangleBar : "\u00e2\u00a7\u0090",
5694 RightTriangle : "\u00e2\u0160\u00b3",
5695 RightTriangleEqual : "\u00e2\u0160\u00b5",
5696 RightUpDownVector : "\u00e2\u00a5\u008f",
5697 RightUpTeeVector : "\u00e2\u00a5\u0153",
5698 RightUpVectorBar : "\u00e2\u00a5\u201d",
5699 RightUpVector : "\u00e2\u2020\u00be",
5700 RightVectorBar : "\u00e2\u00a5\u201c",
5701 RightVector : "\u00e2\u2021\u20ac",
5702 ring : "\u00cb\u0161",
5703 risingdotseq : "\u00e2\u2030\u201c",
5704 rlarr : "\u00e2\u2021\u201e",
5705 rlhar : "\u00e2\u2021\u0152",
5706 rlm : "\u00e2\u20ac\u008f",
5707 rmoustache : "\u00e2\u017d\u00b1",
5708 rmoust : "\u00e2\u017d\u00b1",
5709 rnmid : "\u00e2\u00ab\u00ae",
5710 roang : "\u00e2\u0178\u00ad",
5711 roarr : "\u00e2\u2021\u00be",
5712 robrk : "\u00e2\u0178\u00a7",
5713 ropar : "\u00e2\u00a6\u2020",
5714 ropf : "\u00f0\u009d\u2022\u00a3",
5715 Ropf : "\u00e2\u201e\u009d",
5716 roplus : "\u00e2\u00a8\u00ae",
5717 rotimes : "\u00e2\u00a8\u00b5",
5718 RoundImplies : "\u00e2\u00a5\u00b0",
5719 rpar : ")",
5720 rpargt : "\u00e2\u00a6\u201d",
5721 rppolint : "\u00e2\u00a8\u2019",
5722 rrarr : "\u00e2\u2021\u2030",
5723 Rrightarrow : "\u00e2\u2021\u203a",
5724 rsaquo : "\u00e2\u20ac\u00ba",
5725 rscr : "\u00f0\u009d\u201c\u2021",
5726 Rscr : "\u00e2\u201e\u203a",
5727 rsh : "\u00e2\u2020\u00b1",
5728 Rsh : "\u00e2\u2020\u00b1",
5729 rsqb : "]",
5730 rsquo : "\u00e2\u20ac\u2122",
5731 rsquor : "\u00e2\u20ac\u2122",
5732 rthree : "\u00e2\u2039\u0152",
5733 rtimes : "\u00e2\u2039\u0160",
5734 rtri : "\u00e2\u2013\u00b9",
5735 rtrie : "\u00e2\u0160\u00b5",
5736 rtrif : "\u00e2\u2013\u00b8",
5737 rtriltri : "\u00e2\u00a7\u017d",
5738 RuleDelayed : "\u00e2\u00a7\u00b4",
5739 ruluhar : "\u00e2\u00a5\u00a8",
5740 rx : "\u00e2\u201e\u017e",
5741 Sacute : "\u00c5\u0161",
5742 sacute : "\u00c5\u203a",
5743 sbquo : "\u00e2\u20ac\u0161",
5744 scap : "\u00e2\u00aa\u00b8",
5745 Scaron : "\u00c5 ",
5746 scaron : "\u00c5\u00a1",
5747 Sc : "\u00e2\u00aa\u00bc",
5748 sc : "\u00e2\u2030\u00bb",
5749 sccue : "\u00e2\u2030\u00bd",
5750 sce : "\u00e2\u00aa\u00b0",
5751 scE : "\u00e2\u00aa\u00b4",
5752 Scedil : "\u00c5\u017e",
5753 scedil : "\u00c5\u0178",
5754 Scirc : "\u00c5\u0153",
5755 scirc : "\u00c5\u009d",
5756 scnap : "\u00e2\u00aa\u00ba",
5757 scnE : "\u00e2\u00aa\u00b6",
5758 scnsim : "\u00e2\u2039\u00a9",
5759 scpolint : "\u00e2\u00a8\u201c",
5760 scsim : "\u00e2\u2030\u00bf",
5761 Scy : "\u00d0\u00a1",
5762 scy : "\u00d1\u0081",
5763 sdotb : "\u00e2\u0160\u00a1",
5764 sdot : "\u00e2\u2039\u2026",
5765 sdote : "\u00e2\u00a9\u00a6",
5766 searhk : "\u00e2\u00a4\u00a5",
5767 searr : "\u00e2\u2020\u02dc",
5768 seArr : "\u00e2\u2021\u02dc",
5769 searrow : "\u00e2\u2020\u02dc",
5770 sect : "\u00c2\u00a7",
5771 semi : ";",
5772 seswar : "\u00e2\u00a4\u00a9",
5773 setminus : "\u00e2\u02c6\u2013",
5774 setmn : "\u00e2\u02c6\u2013",
5775 sext : "\u00e2\u0153\u00b6",
5776 Sfr : "\u00f0\u009d\u201d\u2013",
5777 sfr : "\u00f0\u009d\u201d\u00b0",
5778 sfrown : "\u00e2\u0152\u00a2",
5779 sharp : "\u00e2\u2122\u00af",
5780 SHCHcy : "\u00d0\u00a9",
5781 shchcy : "\u00d1\u2030",
5782 SHcy : "\u00d0\u00a8",
5783 shcy : "\u00d1\u02c6",
5784 ShortDownArrow : "\u00e2\u2020\u201c",
5785 ShortLeftArrow : "\u00e2\u2020\u0090",
5786 shortmid : "\u00e2\u02c6\u00a3",
5787 shortparallel : "\u00e2\u02c6\u00a5",
5788 ShortRightArrow : "\u00e2\u2020\u2019",
5789 ShortUpArrow : "\u00e2\u2020\u2018",
5790 shy : "\u00c2\u00ad",
5791 Sigma : "\u00ce\u00a3",
5792 sigma : "\u00cf\u0192",
5793 sigmaf : "\u00cf\u201a",
5794 sigmav : "\u00cf\u201a",
5795 sim : "\u00e2\u02c6\u00bc",
5796 simdot : "\u00e2\u00a9\u00aa",
5797 sime : "\u00e2\u2030\u0192",
5798 simeq : "\u00e2\u2030\u0192",
5799 simg : "\u00e2\u00aa\u017e",
5800 simgE : "\u00e2\u00aa ",
5801 siml : "\u00e2\u00aa\u009d",
5802 simlE : "\u00e2\u00aa\u0178",
5803 simne : "\u00e2\u2030\u2020",
5804 simplus : "\u00e2\u00a8\u00a4",
5805 simrarr : "\u00e2\u00a5\u00b2",
5806 slarr : "\u00e2\u2020\u0090",
5807 SmallCircle : "\u00e2\u02c6\u02dc",
5808 smallsetminus : "\u00e2\u02c6\u2013",
5809 smashp : "\u00e2\u00a8\u00b3",
5810 smeparsl : "\u00e2\u00a7\u00a4",
5811 smid : "\u00e2\u02c6\u00a3",
5812 smile : "\u00e2\u0152\u00a3",
5813 smt : "\u00e2\u00aa\u00aa",
5814 smte : "\u00e2\u00aa\u00ac",
5815 smtes : "\u00e2\u00aa\u00ac\u00ef\u00b8\u20ac",
5816 SOFTcy : "\u00d0\u00ac",
5817 softcy : "\u00d1\u0152",
5818 solbar : "\u00e2\u0152\u00bf",
5819 solb : "\u00e2\u00a7\u201e",
5820 sol : "/",
5821 Sopf : "\u00f0\u009d\u2022\u0160",
5822 sopf : "\u00f0\u009d\u2022\u00a4",
5823 spades : "\u00e2\u2122 ",
5824 spadesuit : "\u00e2\u2122 ",
5825 spar : "\u00e2\u02c6\u00a5",
5826 sqcap : "\u00e2\u0160\u201c",
5827 sqcaps : "\u00e2\u0160\u201c\u00ef\u00b8\u20ac",
5828 sqcup : "\u00e2\u0160\u201d",
5829 sqcups : "\u00e2\u0160\u201d\u00ef\u00b8\u20ac",
5830 Sqrt : "\u00e2\u02c6\u0161",
5831 sqsub : "\u00e2\u0160\u008f",
5832 sqsube : "\u00e2\u0160\u2018",
5833 sqsubset : "\u00e2\u0160\u008f",
5834 sqsubseteq : "\u00e2\u0160\u2018",
5835 sqsup : "\u00e2\u0160\u0090",
5836 sqsupe : "\u00e2\u0160\u2019",
5837 sqsupset : "\u00e2\u0160\u0090",
5838 sqsupseteq : "\u00e2\u0160\u2019",
5839 square : "\u00e2\u2013\u00a1",
5840 Square : "\u00e2\u2013\u00a1",
5841 SquareIntersection : "\u00e2\u0160\u201c",
5842 SquareSubset : "\u00e2\u0160\u008f",
5843 SquareSubsetEqual : "\u00e2\u0160\u2018",
5844 SquareSuperset : "\u00e2\u0160\u0090",
5845 SquareSupersetEqual : "\u00e2\u0160\u2019",
5846 SquareUnion : "\u00e2\u0160\u201d",
5847 squarf : "\u00e2\u2013\u00aa",
5848 squ : "\u00e2\u2013\u00a1",
5849 squf : "\u00e2\u2013\u00aa",
5850 srarr : "\u00e2\u2020\u2019",
5851 Sscr : "\u00f0\u009d\u2019\u00ae",
5852 sscr : "\u00f0\u009d\u201c\u02c6",
5853 ssetmn : "\u00e2\u02c6\u2013",
5854 ssmile : "\u00e2\u0152\u00a3",
5855 sstarf : "\u00e2\u2039\u2020",
5856 Star : "\u00e2\u2039\u2020",
5857 star : "\u00e2\u02dc\u2020",
5858 starf : "\u00e2\u02dc\u2026",
5859 straightepsilon : "\u00cf\u00b5",
5860 straightphi : "\u00cf\u2022",
5861 strns : "\u00c2\u00af",
5862 sub : "\u00e2\u0160\u201a",
5863 Sub : "\u00e2\u2039\u0090",
5864 subdot : "\u00e2\u00aa\u00bd",
5865 subE : "\u00e2\u00ab\u2026",
5866 sube : "\u00e2\u0160\u2020",
5867 subedot : "\u00e2\u00ab\u0192",
5868 submult : "\u00e2\u00ab\u0081",
5869 subnE : "\u00e2\u00ab\u2039",
5870 subne : "\u00e2\u0160\u0160",
5871 subplus : "\u00e2\u00aa\u00bf",
5872 subrarr : "\u00e2\u00a5\u00b9",
5873 subset : "\u00e2\u0160\u201a",
5874 Subset : "\u00e2\u2039\u0090",
5875 subseteq : "\u00e2\u0160\u2020",
5876 subseteqq : "\u00e2\u00ab\u2026",
5877 SubsetEqual : "\u00e2\u0160\u2020",
5878 subsetneq : "\u00e2\u0160\u0160",
5879 subsetneqq : "\u00e2\u00ab\u2039",
5880 subsim : "\u00e2\u00ab\u2021",
5881 subsub : "\u00e2\u00ab\u2022",
5882 subsup : "\u00e2\u00ab\u201c",
5883 succapprox : "\u00e2\u00aa\u00b8",
5884 succ : "\u00e2\u2030\u00bb",
5885 succcurlyeq : "\u00e2\u2030\u00bd",
5886 Succeeds : "\u00e2\u2030\u00bb",
5887 SucceedsEqual : "\u00e2\u00aa\u00b0",
5888 SucceedsSlantEqual : "\u00e2\u2030\u00bd",
5889 SucceedsTilde : "\u00e2\u2030\u00bf",
5890 succeq : "\u00e2\u00aa\u00b0",
5891 succnapprox : "\u00e2\u00aa\u00ba",
5892 succneqq : "\u00e2\u00aa\u00b6",
5893 succnsim : "\u00e2\u2039\u00a9",
5894 succsim : "\u00e2\u2030\u00bf",
5895 SuchThat : "\u00e2\u02c6\u2039",
5896 sum : "\u00e2\u02c6\u2018",
5897 Sum : "\u00e2\u02c6\u2018",
5898 sung : "\u00e2\u2122\u00aa",
5899 sup1 : "\u00c2\u00b9",
5900 sup2 : "\u00c2\u00b2",
5901 sup3 : "\u00c2\u00b3",
5902 sup : "\u00e2\u0160\u0192",
5903 Sup : "\u00e2\u2039\u2018",
5904 supdot : "\u00e2\u00aa\u00be",
5905 supdsub : "\u00e2\u00ab\u02dc",
5906 supE : "\u00e2\u00ab\u2020",
5907 supe : "\u00e2\u0160\u2021",
5908 supedot : "\u00e2\u00ab\u201e",
5909 Superset : "\u00e2\u0160\u0192",
5910 SupersetEqual : "\u00e2\u0160\u2021",
5911 suphsol : "\u00e2\u0178\u2030",
5912 suphsub : "\u00e2\u00ab\u2014",
5913 suplarr : "\u00e2\u00a5\u00bb",
5914 supmult : "\u00e2\u00ab\u201a",
5915 supnE : "\u00e2\u00ab\u0152",
5916 supne : "\u00e2\u0160\u2039",
5917 supplus : "\u00e2\u00ab\u20ac",
5918 supset : "\u00e2\u0160\u0192",
5919 Supset : "\u00e2\u2039\u2018",
5920 supseteq : "\u00e2\u0160\u2021",
5921 supseteqq : "\u00e2\u00ab\u2020",
5922 supsetneq : "\u00e2\u0160\u2039",
5923 supsetneqq : "\u00e2\u00ab\u0152",
5924 supsim : "\u00e2\u00ab\u02c6",
5925 supsub : "\u00e2\u00ab\u201d",
5926 supsup : "\u00e2\u00ab\u2013",
5927 swarhk : "\u00e2\u00a4\u00a6",
5928 swarr : "\u00e2\u2020\u2122",
5929 swArr : "\u00e2\u2021\u2122",
5930 swarrow : "\u00e2\u2020\u2122",
5931 swnwar : "\u00e2\u00a4\u00aa",
5932 szlig : "\u00c3\u0178",
5933 Tab : "\t",
5934 target : "\u00e2\u0152\u2013",
5935 Tau : "\u00ce\u00a4",
5936 tau : "\u00cf\u201e",
5937 tbrk : "\u00e2\u017d\u00b4",
5938 Tcaron : "\u00c5\u00a4",
5939 tcaron : "\u00c5\u00a5",
5940 Tcedil : "\u00c5\u00a2",
5941 tcedil : "\u00c5\u00a3",
5942 Tcy : "\u00d0\u00a2",
5943 tcy : "\u00d1\u201a",
5944 tdot : "\u00e2\u0192\u203a",
5945 telrec : "\u00e2\u0152\u2022",
5946 Tfr : "\u00f0\u009d\u201d\u2014",
5947 tfr : "\u00f0\u009d\u201d\u00b1",
5948 there4 : "\u00e2\u02c6\u00b4",
5949 therefore : "\u00e2\u02c6\u00b4",
5950 Therefore : "\u00e2\u02c6\u00b4",
5951 Theta : "\u00ce\u02dc",
5952 theta : "\u00ce\u00b8",
5953 thetasym : "\u00cf\u2018",
5954 thetav : "\u00cf\u2018",
5955 thickapprox : "\u00e2\u2030\u02c6",
5956 thicksim : "\u00e2\u02c6\u00bc",
5957 ThickSpace : "\u00e2\u0081\u0178\u00e2\u20ac\u0160",
5958 ThinSpace : "\u00e2\u20ac\u2030",
5959 thinsp : "\u00e2\u20ac\u2030",
5960 thkap : "\u00e2\u2030\u02c6",
5961 thksim : "\u00e2\u02c6\u00bc",
5962 THORN : "\u00c3\u017e",
5963 thorn : "\u00c3\u00be",
5964 tilde : "\u00cb\u0153",
5965 Tilde : "\u00e2\u02c6\u00bc",
5966 TildeEqual : "\u00e2\u2030\u0192",
5967 TildeFullEqual : "\u00e2\u2030\u2026",
5968 TildeTilde : "\u00e2\u2030\u02c6",
5969 timesbar : "\u00e2\u00a8\u00b1",
5970 timesb : "\u00e2\u0160 ",
5971 times : "\u00c3\u2014",
5972 timesd : "\u00e2\u00a8\u00b0",
5973 tint : "\u00e2\u02c6\u00ad",
5974 toea : "\u00e2\u00a4\u00a8",
5975 topbot : "\u00e2\u0152\u00b6",
5976 topcir : "\u00e2\u00ab\u00b1",
5977 top : "\u00e2\u0160\u00a4",
5978 Topf : "\u00f0\u009d\u2022\u2039",
5979 topf : "\u00f0\u009d\u2022\u00a5",
5980 topfork : "\u00e2\u00ab\u0161",
5981 tosa : "\u00e2\u00a4\u00a9",
5982 tprime : "\u00e2\u20ac\u00b4",
5983 trade : "\u00e2\u201e\u00a2",
5984 TRADE : "\u00e2\u201e\u00a2",
5985 triangle : "\u00e2\u2013\u00b5",
5986 triangledown : "\u00e2\u2013\u00bf",
5987 triangleleft : "\u00e2\u2014\u0192",
5988 trianglelefteq : "\u00e2\u0160\u00b4",
5989 triangleq : "\u00e2\u2030\u0153",
5990 triangleright : "\u00e2\u2013\u00b9",
5991 trianglerighteq : "\u00e2\u0160\u00b5",
5992 tridot : "\u00e2\u2014\u00ac",
5993 trie : "\u00e2\u2030\u0153",
5994 triminus : "\u00e2\u00a8\u00ba",
5995 TripleDot : "\u00e2\u0192\u203a",
5996 triplus : "\u00e2\u00a8\u00b9",
5997 trisb : "\u00e2\u00a7\u008d",
5998 tritime : "\u00e2\u00a8\u00bb",
5999 trpezium : "\u00e2\u008f\u00a2",
6000 Tscr : "\u00f0\u009d\u2019\u00af",
6001 tscr : "\u00f0\u009d\u201c\u2030",
6002 TScy : "\u00d0\u00a6",
6003 tscy : "\u00d1\u2020",
6004 TSHcy : "\u00d0\u2039",
6005 tshcy : "\u00d1\u203a",
6006 Tstrok : "\u00c5\u00a6",
6007 tstrok : "\u00c5\u00a7",
6008 twixt : "\u00e2\u2030\u00ac",
6009 twoheadleftarrow : "\u00e2\u2020\u017e",
6010 twoheadrightarrow : "\u00e2\u2020 ",
6011 Uacute : "\u00c3\u0161",
6012 uacute : "\u00c3\u00ba",
6013 uarr : "\u00e2\u2020\u2018",
6014 Uarr : "\u00e2\u2020\u0178",
6015 uArr : "\u00e2\u2021\u2018",
6016 Uarrocir : "\u00e2\u00a5\u2030",
6017 Ubrcy : "\u00d0\u017d",
6018 ubrcy : "\u00d1\u017e",
6019 Ubreve : "\u00c5\u00ac",
6020 ubreve : "\u00c5\u00ad",
6021 Ucirc : "\u00c3\u203a",
6022 ucirc : "\u00c3\u00bb",
6023 Ucy : "\u00d0\u00a3",
6024 ucy : "\u00d1\u0192",
6025 udarr : "\u00e2\u2021\u2026",
6026 Udblac : "\u00c5\u00b0",
6027 udblac : "\u00c5\u00b1",
6028 udhar : "\u00e2\u00a5\u00ae",
6029 ufisht : "\u00e2\u00a5\u00be",
6030 Ufr : "\u00f0\u009d\u201d\u02dc",
6031 ufr : "\u00f0\u009d\u201d\u00b2",
6032 Ugrave : "\u00c3\u2122",
6033 ugrave : "\u00c3\u00b9",
6034 uHar : "\u00e2\u00a5\u00a3",
6035 uharl : "\u00e2\u2020\u00bf",
6036 uharr : "\u00e2\u2020\u00be",
6037 uhblk : "\u00e2\u2013\u20ac",
6038 ulcorn : "\u00e2\u0152\u0153",
6039 ulcorner : "\u00e2\u0152\u0153",
6040 ulcrop : "\u00e2\u0152\u008f",
6041 ultri : "\u00e2\u2014\u00b8",
6042 Umacr : "\u00c5\u00aa",
6043 umacr : "\u00c5\u00ab",
6044 uml : "\u00c2\u00a8",
6045 UnderBar : "_",
6046 UnderBrace : "\u00e2\u008f\u0178",
6047 UnderBracket : "\u00e2\u017d\u00b5",
6048 UnderParenthesis : "\u00e2\u008f\u009d",
6049 Union : "\u00e2\u2039\u0192",
6050 UnionPlus : "\u00e2\u0160\u017d",
6051 Uogon : "\u00c5\u00b2",
6052 uogon : "\u00c5\u00b3",
6053 Uopf : "\u00f0\u009d\u2022\u0152",
6054 uopf : "\u00f0\u009d\u2022\u00a6",
6055 UpArrowBar : "\u00e2\u00a4\u2019",
6056 uparrow : "\u00e2\u2020\u2018",
6057 UpArrow : "\u00e2\u2020\u2018",
6058 Uparrow : "\u00e2\u2021\u2018",
6059 UpArrowDownArrow : "\u00e2\u2021\u2026",
6060 updownarrow : "\u00e2\u2020\u2022",
6061 UpDownArrow : "\u00e2\u2020\u2022",
6062 Updownarrow : "\u00e2\u2021\u2022",
6063 UpEquilibrium : "\u00e2\u00a5\u00ae",
6064 upharpoonleft : "\u00e2\u2020\u00bf",
6065 upharpoonright : "\u00e2\u2020\u00be",
6066 uplus : "\u00e2\u0160\u017d",
6067 UpperLeftArrow : "\u00e2\u2020\u2013",
6068 UpperRightArrow : "\u00e2\u2020\u2014",
6069 upsi : "\u00cf\u2026",
6070 Upsi : "\u00cf\u2019",
6071 upsih : "\u00cf\u2019",
6072 Upsilon : "\u00ce\u00a5",
6073 upsilon : "\u00cf\u2026",
6074 UpTeeArrow : "\u00e2\u2020\u00a5",
6075 UpTee : "\u00e2\u0160\u00a5",
6076 upuparrows : "\u00e2\u2021\u02c6",
6077 urcorn : "\u00e2\u0152\u009d",
6078 urcorner : "\u00e2\u0152\u009d",
6079 urcrop : "\u00e2\u0152\u017d",
6080 Uring : "\u00c5\u00ae",
6081 uring : "\u00c5\u00af",
6082 urtri : "\u00e2\u2014\u00b9",
6083 Uscr : "\u00f0\u009d\u2019\u00b0",
6084 uscr : "\u00f0\u009d\u201c\u0160",
6085 utdot : "\u00e2\u2039\u00b0",
6086 Utilde : "\u00c5\u00a8",
6087 utilde : "\u00c5\u00a9",
6088 utri : "\u00e2\u2013\u00b5",
6089 utrif : "\u00e2\u2013\u00b4",
6090 uuarr : "\u00e2\u2021\u02c6",
6091 Uuml : "\u00c3\u0153",
6092 uuml : "\u00c3\u00bc",
6093 uwangle : "\u00e2\u00a6\u00a7",
6094 vangrt : "\u00e2\u00a6\u0153",
6095 varepsilon : "\u00cf\u00b5",
6096 varkappa : "\u00cf\u00b0",
6097 varnothing : "\u00e2\u02c6\u2026",
6098 varphi : "\u00cf\u2022",
6099 varpi : "\u00cf\u2013",
6100 varpropto : "\u00e2\u02c6\u009d",
6101 varr : "\u00e2\u2020\u2022",
6102 vArr : "\u00e2\u2021\u2022",
6103 varrho : "\u00cf\u00b1",
6104 varsigma : "\u00cf\u201a",
6105 varsubsetneq : "\u00e2\u0160\u0160\u00ef\u00b8\u20ac",
6106 varsubsetneqq : "\u00e2\u00ab\u2039\u00ef\u00b8\u20ac",
6107 varsupsetneq : "\u00e2\u0160\u2039\u00ef\u00b8\u20ac",
6108 varsupsetneqq : "\u00e2\u00ab\u0152\u00ef\u00b8\u20ac",
6109 vartheta : "\u00cf\u2018",
6110 vartriangleleft : "\u00e2\u0160\u00b2",
6111 vartriangleright : "\u00e2\u0160\u00b3",
6112 vBar : "\u00e2\u00ab\u00a8",
6113 Vbar : "\u00e2\u00ab\u00ab",
6114 vBarv : "\u00e2\u00ab\u00a9",
6115 Vcy : "\u00d0\u2019",
6116 vcy : "\u00d0\u00b2",
6117 vdash : "\u00e2\u0160\u00a2",
6118 vDash : "\u00e2\u0160\u00a8",
6119 Vdash : "\u00e2\u0160\u00a9",
6120 VDash : "\u00e2\u0160\u00ab",
6121 Vdashl : "\u00e2\u00ab\u00a6",
6122 veebar : "\u00e2\u0160\u00bb",
6123 vee : "\u00e2\u02c6\u00a8",
6124 Vee : "\u00e2\u2039\u0081",
6125 veeeq : "\u00e2\u2030\u0161",
6126 vellip : "\u00e2\u2039\u00ae",
6127 verbar : "|",
6128 Verbar : "\u00e2\u20ac\u2013",
6129 vert : "|",
6130 Vert : "\u00e2\u20ac\u2013",
6131 VerticalBar : "\u00e2\u02c6\u00a3",
6132 VerticalLine : "|",
6133 VerticalSeparator : "\u00e2\u009d\u02dc",
6134 VerticalTilde : "\u00e2\u2030\u20ac",
6135 VeryThinSpace : "\u00e2\u20ac\u0160",
6136 Vfr : "\u00f0\u009d\u201d\u2122",
6137 vfr : "\u00f0\u009d\u201d\u00b3",
6138 vltri : "\u00e2\u0160\u00b2",
6139 vnsub : "\u00e2\u0160\u201a\u00e2\u0192\u2019",
6140 vnsup : "\u00e2\u0160\u0192\u00e2\u0192\u2019",
6141 Vopf : "\u00f0\u009d\u2022\u008d",
6142 vopf : "\u00f0\u009d\u2022\u00a7",
6143 vprop : "\u00e2\u02c6\u009d",
6144 vrtri : "\u00e2\u0160\u00b3",
6145 Vscr : "\u00f0\u009d\u2019\u00b1",
6146 vscr : "\u00f0\u009d\u201c\u2039",
6147 vsubnE : "\u00e2\u00ab\u2039\u00ef\u00b8\u20ac",
6148 vsubne : "\u00e2\u0160\u0160\u00ef\u00b8\u20ac",
6149 vsupnE : "\u00e2\u00ab\u0152\u00ef\u00b8\u20ac",
6150 vsupne : "\u00e2\u0160\u2039\u00ef\u00b8\u20ac",
6151 Vvdash : "\u00e2\u0160\u00aa",
6152 vzigzag : "\u00e2\u00a6\u0161",
6153 Wcirc : "\u00c5\u00b4",
6154 wcirc : "\u00c5\u00b5",
6155 wedbar : "\u00e2\u00a9\u0178",
6156 wedge : "\u00e2\u02c6\u00a7",
6157 Wedge : "\u00e2\u2039\u20ac",
6158 wedgeq : "\u00e2\u2030\u2122",
6159 weierp : "\u00e2\u201e\u02dc",
6160 Wfr : "\u00f0\u009d\u201d\u0161",
6161 wfr : "\u00f0\u009d\u201d\u00b4",
6162 Wopf : "\u00f0\u009d\u2022\u017d",
6163 wopf : "\u00f0\u009d\u2022\u00a8",
6164 wp : "\u00e2\u201e\u02dc",
6165 wr : "\u00e2\u2030\u20ac",
6166 wreath : "\u00e2\u2030\u20ac",
6167 Wscr : "\u00f0\u009d\u2019\u00b2",
6168 wscr : "\u00f0\u009d\u201c\u0152",
6169 xcap : "\u00e2\u2039\u201a",
6170 xcirc : "\u00e2\u2014\u00af",
6171 xcup : "\u00e2\u2039\u0192",
6172 xdtri : "\u00e2\u2013\u00bd",
6173 Xfr : "\u00f0\u009d\u201d\u203a",
6174 xfr : "\u00f0\u009d\u201d\u00b5",
6175 xharr : "\u00e2\u0178\u00b7",
6176 xhArr : "\u00e2\u0178\u00ba",
6177 Xi : "\u00ce\u017e",
6178 xi : "\u00ce\u00be",
6179 xlarr : "\u00e2\u0178\u00b5",
6180 xlArr : "\u00e2\u0178\u00b8",
6181 xmap : "\u00e2\u0178\u00bc",
6182 xnis : "\u00e2\u2039\u00bb",
6183 xodot : "\u00e2\u00a8\u20ac",
6184 Xopf : "\u00f0\u009d\u2022\u008f",
6185 xopf : "\u00f0\u009d\u2022\u00a9",
6186 xoplus : "\u00e2\u00a8\u0081",
6187 xotime : "\u00e2\u00a8\u201a",
6188 xrarr : "\u00e2\u0178\u00b6",
6189 xrArr : "\u00e2\u0178\u00b9",
6190 Xscr : "\u00f0\u009d\u2019\u00b3",
6191 xscr : "\u00f0\u009d\u201c\u008d",
6192 xsqcup : "\u00e2\u00a8\u2020",
6193 xuplus : "\u00e2\u00a8\u201e",
6194 xutri : "\u00e2\u2013\u00b3",
6195 xvee : "\u00e2\u2039\u0081",
6196 xwedge : "\u00e2\u2039\u20ac",
6197 Yacute : "\u00c3\u009d",
6198 yacute : "\u00c3\u00bd",
6199 YAcy : "\u00d0\u00af",
6200 yacy : "\u00d1\u008f",
6201 Ycirc : "\u00c5\u00b6",
6202 ycirc : "\u00c5\u00b7",
6203 Ycy : "\u00d0\u00ab",
6204 ycy : "\u00d1\u2039",
6205 yen : "\u00c2\u00a5",
6206 Yfr : "\u00f0\u009d\u201d\u0153",
6207 yfr : "\u00f0\u009d\u201d\u00b6",
6208 YIcy : "\u00d0\u2021",
6209 yicy : "\u00d1\u2014",
6210 Yopf : "\u00f0\u009d\u2022\u0090",
6211 yopf : "\u00f0\u009d\u2022\u00aa",
6212 Yscr : "\u00f0\u009d\u2019\u00b4",
6213 yscr : "\u00f0\u009d\u201c\u017d",
6214 YUcy : "\u00d0\u00ae",
6215 yucy : "\u00d1\u017d",
6216 yuml : "\u00c3\u00bf",
6217 Yuml : "\u00c5\u00b8",
6218 Zacute : "\u00c5\u00b9",
6219 zacute : "\u00c5\u00ba",
6220 Zcaron : "\u00c5\u00bd",
6221 zcaron : "\u00c5\u00be",
6222 Zcy : "\u00d0\u2014",
6223 zcy : "\u00d0\u00b7",
6224 Zdot : "\u00c5\u00bb",
6225 zdot : "\u00c5\u00bc",
6226 zeetrf : "\u00e2\u201e\u00a8",
6227 ZeroWidthSpace : "\u00e2\u20ac\u2039",
6228 Zeta : "\u00ce\u2013",
6229 zeta : "\u00ce\u00b6",
6230 zfr : "\u00f0\u009d\u201d\u00b7",
6231 Zfr : "\u00e2\u201e\u00a8",
6232 ZHcy : "\u00d0\u2013",
6233 zhcy : "\u00d0\u00b6",
6234 zigrarr : "\u00e2\u2021\u009d",
6235 zopf : "\u00f0\u009d\u2022\u00ab",
6236 Zopf : "\u00e2\u201e\u00a4",
6237 Zscr : "\u00f0\u009d\u2019\u00b5",
6238 zscr : "\u00f0\u009d\u201c\u008f",
6239 zwj : "\u00e2\u20ac\u008d",
6240 zwnj : "\u00e2\u20ac\u0152"
6241 };
6242 }, {}],
6243 6 : [function(dataAndEvents, module, deepDataAndEvents) {
6244 module.exports = {
6245 Aacute : "\u00c3\u0081",
6246 aacute : "\u00c3\u00a1",
6247 Acirc : "\u00c3\u201a",
6248 acirc : "\u00c3\u00a2",
6249 acute : "\u00c2\u00b4",
6250 AElig : "\u00c3\u2020",
6251 aelig : "\u00c3\u00a6",
6252 Agrave : "\u00c3\u20ac",
6253 agrave : "\u00c3 ",
6254 amp : "&",
6255 AMP : "&",
6256 Aring : "\u00c3\u2026",
6257 aring : "\u00c3\u00a5",
6258 Atilde : "\u00c3\u0192",
6259 atilde : "\u00c3\u00a3",
6260 Auml : "\u00c3\u201e",
6261 auml : "\u00c3\u00a4",
6262 brvbar : "\u00c2\u00a6",
6263 Ccedil : "\u00c3\u2021",
6264 ccedil : "\u00c3\u00a7",
6265 cedil : "\u00c2\u00b8",
6266 cent : "\u00c2\u00a2",
6267 copy : "\u00c2\u00a9",
6268 COPY : "\u00c2\u00a9",
6269 curren : "\u00c2\u00a4",
6270 deg : "\u00c2\u00b0",
6271 divide : "\u00c3\u00b7",
6272 Eacute : "\u00c3\u2030",
6273 eacute : "\u00c3\u00a9",
6274 Ecirc : "\u00c3\u0160",
6275 ecirc : "\u00c3\u00aa",
6276 Egrave : "\u00c3\u02c6",
6277 egrave : "\u00c3\u00a8",
6278 ETH : "\u00c3\u0090",
6279 eth : "\u00c3\u00b0",
6280 Euml : "\u00c3\u2039",
6281 euml : "\u00c3\u00ab",
6282 frac12 : "\u00c2\u00bd",
6283 frac14 : "\u00c2\u00bc",
6284 frac34 : "\u00c2\u00be",
6285 gt : ">",
6286 GT : ">",
6287 Iacute : "\u00c3\u008d",
6288 iacute : "\u00c3\u00ad",
6289 Icirc : "\u00c3\u017d",
6290 icirc : "\u00c3\u00ae",
6291 iexcl : "\u00c2\u00a1",
6292 Igrave : "\u00c3\u0152",
6293 igrave : "\u00c3\u00ac",
6294 iquest : "\u00c2\u00bf",
6295 Iuml : "\u00c3\u008f",
6296 iuml : "\u00c3\u00af",
6297 laquo : "\u00c2\u00ab",
6298 lt : "<",
6299 LT : "<",
6300 macr : "\u00c2\u00af",
6301 micro : "\u00c2\u00b5",
6302 middot : "\u00c2\u00b7",
6303 nbsp : "\u00c2 ",
6304 not : "\u00c2\u00ac",
6305 Ntilde : "\u00c3\u2018",
6306 ntilde : "\u00c3\u00b1",
6307 Oacute : "\u00c3\u201c",
6308 oacute : "\u00c3\u00b3",
6309 Ocirc : "\u00c3\u201d",
6310 ocirc : "\u00c3\u00b4",
6311 Ograve : "\u00c3\u2019",
6312 ograve : "\u00c3\u00b2",
6313 ordf : "\u00c2\u00aa",
6314 ordm : "\u00c2\u00ba",
6315 Oslash : "\u00c3\u02dc",
6316 oslash : "\u00c3\u00b8",
6317 Otilde : "\u00c3\u2022",
6318 otilde : "\u00c3\u00b5",
6319 Ouml : "\u00c3\u2013",
6320 ouml : "\u00c3\u00b6",
6321 para : "\u00c2\u00b6",
6322 plusmn : "\u00c2\u00b1",
6323 pound : "\u00c2\u00a3",
6324 quot : '"',
6325 QUOT : '"',
6326 raquo : "\u00c2\u00bb",
6327 reg : "\u00c2\u00ae",
6328 REG : "\u00c2\u00ae",
6329 sect : "\u00c2\u00a7",
6330 shy : "\u00c2\u00ad",
6331 sup1 : "\u00c2\u00b9",
6332 sup2 : "\u00c2\u00b2",
6333 sup3 : "\u00c2\u00b3",
6334 szlig : "\u00c3\u0178",
6335 THORN : "\u00c3\u017e",
6336 thorn : "\u00c3\u00be",
6337 times : "\u00c3\u2014",
6338 Uacute : "\u00c3\u0161",
6339 uacute : "\u00c3\u00ba",
6340 Ucirc : "\u00c3\u203a",
6341 ucirc : "\u00c3\u00bb",
6342 Ugrave : "\u00c3\u2122",
6343 ugrave : "\u00c3\u00b9",
6344 uml : "\u00c2\u00a8",
6345 Uuml : "\u00c3\u0153",
6346 uuml : "\u00c3\u00bc",
6347 Yacute : "\u00c3\u009d",
6348 yacute : "\u00c3\u00bd",
6349 yen : "\u00c2\u00a5",
6350 yuml : "\u00c3\u00bf"
6351 };
6352 }, {}],
6353 7 : [function(dataAndEvents, module, deepDataAndEvents) {
6354 module.exports = {
6355 amp : "&",
6356 apos : "'",
6357 gt : ">",
6358 lt : "<",
6359 quot : '"'
6360 };
6361 }, {}]
6362 }, {}, [1])(1);
6363 var Scanner = function e(t, n, r) {
6364 /**
6365 * @param {string} o
6366 * @param {?} u
6367 * @return {?}
6368 */
6369 function s(o, u) {
6370 if (!n[o]) {
6371 if (!t[o]) {
6372 var a = "function" == typeof require && require;
6373 if (!u && a) {
6374 return a(o, true);
6375 }
6376 if (i) {
6377 return i(o, true);
6378 }
6379 throw new Error("Cannot find module '" + o + "'");
6380 }
6381 var module_ = n[o] = {
6382 exports : {}
6383 };
6384 t[o][0].call(module_.exports, function(from) {
6385 var to = t[o][1][from];
6386 return s(to || from);
6387 }, module_, module_.exports, e, t, n, r);
6388 }
6389 return n[o].exports;
6390 }
6391 var i = "function" == typeof require && require;
6392 /** @type {number} */
6393 var o = 0;
6394 for (;o < r.length;o++) {
6395 s(r[o]);
6396 }
6397 return s;
6398 }({
6399 1 : [function($sanitize, module, dataAndEvents) {
6400 /**
6401 * @param {Object} o
6402 * @param {Object} options
6403 * @param {Function} fn
6404 * @return {undefined}
6405 */
6406 function run(o, options, fn) {
6407 if ("object" == typeof o) {
6408 /** @type {Object} */
6409 fn = options;
6410 /** @type {Object} */
6411 options = o;
6412 /** @type {null} */
6413 o = null;
6414 } else {
6415 if ("function" == typeof options) {
6416 /** @type {Object} */
6417 fn = options;
6418 options = EMPTY_OBJECT;
6419 }
6420 }
6421 /** @type {Object} */
6422 this._callback = o;
6423 this._options = options || EMPTY_OBJECT;
6424 /** @type {Function} */
6425 this._elementCB = fn;
6426 /** @type {Array} */
6427 this.dom = [];
6428 /** @type {boolean} */
6429 this._done = false;
6430 /** @type {Array} */
6431 this._tagStack = [];
6432 }
6433 var ElementType = $sanitize("domelementtype");
6434 /** @type {RegExp} */
6435 var jsre = /\s+/g;
6436 var EMPTY_OBJECT = {
6437 normalizeWhitespace : false
6438 };
6439 /**
6440 * @return {undefined}
6441 */
6442 run.prototype.onreset = function() {
6443 run.call(this, this._callback, this._options, this._elementCB);
6444 };
6445 /**
6446 * @return {undefined}
6447 */
6448 run.prototype.onend = function() {
6449 if (!this._done) {
6450 /** @type {boolean} */
6451 this._done = true;
6452 this._handleCallback(null);
6453 }
6454 };
6455 /** @type {function (Error): undefined} */
6456 run.prototype._handleCallback = run.prototype.onerror = function(error) {
6457 if ("function" == typeof this._callback) {
6458 this._callback(error, this.dom);
6459 } else {
6460 if (error) {
6461 throw error;
6462 }
6463 }
6464 };
6465 /**
6466 * @return {undefined}
6467 */
6468 run.prototype.onclosetag = function() {
6469 var r20 = this._tagStack.pop();
6470 if (this._elementCB) {
6471 this._elementCB(r20);
6472 }
6473 };
6474 /**
6475 * @param {Object} element
6476 * @return {undefined}
6477 */
6478 run.prototype._addDomElement = function(element) {
6479 var parent = this._tagStack[this._tagStack.length - 1];
6480 var dom = parent ? parent.children : this.dom;
6481 var e = dom[dom.length - 1];
6482 /** @type {null} */
6483 element.next = null;
6484 if (e) {
6485 element.prev = e;
6486 /** @type {Object} */
6487 e.next = element;
6488 } else {
6489 /** @type {null} */
6490 element.prev = null;
6491 }
6492 dom.push(element);
6493 element.parent = parent || null;
6494 };
6495 /**
6496 * @param {string} tag
6497 * @param {Object} attribs
6498 * @return {undefined}
6499 */
6500 run.prototype.onopentag = function(tag, attribs) {
6501 var element = {
6502 type : "script" === tag ? ElementType.Script : "style" === tag ? ElementType.Style : ElementType.Tag,
6503 name : tag,
6504 attribs : attribs,
6505 children : []
6506 };
6507 this._addDomElement(element);
6508 this._tagStack.push(element);
6509 };
6510 /**
6511 * @param {string} data
6512 * @return {undefined}
6513 */
6514 run.prototype.ontext = function(data) {
6515 var lastTag;
6516 var n = this._options.normalizeWhitespace || this._options.ignoreWhitespace;
6517 if (!this._tagStack.length && (this.dom.length && (lastTag = this.dom[this.dom.length - 1]).type === ElementType.Text)) {
6518 if (n) {
6519 lastTag.data = (lastTag.data + data).replace(jsre, " ");
6520 } else {
6521 lastTag.data += data;
6522 }
6523 } else {
6524 if (this._tagStack.length && ((lastTag = this._tagStack[this._tagStack.length - 1]) && ((lastTag = lastTag.children[lastTag.children.length - 1]) && lastTag.type === ElementType.Text))) {
6525 if (n) {
6526 lastTag.data = (lastTag.data + data).replace(jsre, " ");
6527 } else {
6528 lastTag.data += data;
6529 }
6530 } else {
6531 if (n) {
6532 data = data.replace(jsre, " ");
6533 }
6534 this._addDomElement({
6535 data : data,
6536 type : ElementType.Text
6537 });
6538 }
6539 }
6540 };
6541 /**
6542 * @param {string} data
6543 * @return {undefined}
6544 */
6545 run.prototype.oncomment = function(data) {
6546 var lastTag = this._tagStack[this._tagStack.length - 1];
6547 if (lastTag && lastTag.type === ElementType.Comment) {
6548 lastTag.data += data;
6549 } else {
6550 var element = {
6551 data : data,
6552 type : ElementType.Comment
6553 };
6554 this._addDomElement(element);
6555 this._tagStack.push(element);
6556 }
6557 };
6558 /**
6559 * @return {undefined}
6560 */
6561 run.prototype.oncdatastart = function() {
6562 var element = {
6563 children : [{
6564 data : "",
6565 type : ElementType.Text
6566 }],
6567 type : ElementType.CDATA
6568 };
6569 this._addDomElement(element);
6570 this._tagStack.push(element);
6571 };
6572 /** @type {function (): undefined} */
6573 run.prototype.oncommentend = run.prototype.oncdataend = function() {
6574 this._tagStack.pop();
6575 };
6576 /**
6577 * @param {string} name
6578 * @param {Object} data
6579 * @return {undefined}
6580 */
6581 run.prototype.onprocessinginstruction = function(name, data) {
6582 this._addDomElement({
6583 name : name,
6584 data : data,
6585 type : ElementType.Directive
6586 });
6587 };
6588 /** @type {function (Object, Object, Function): undefined} */
6589 module.exports = run;
6590 }, {
6591 domelementtype : 2
6592 }],
6593 2 : [function(dataAndEvents, module, deepDataAndEvents) {
6594 module.exports = {
6595 Text : "text",
6596 Directive : "directive",
6597 Comment : "comment",
6598 Script : "script",
6599 Style : "style",
6600 Tag : "tag",
6601 CDATA : "cdata",
6602 /**
6603 * @param {Event} e
6604 * @return {?}
6605 */
6606 isTag : function(e) {
6607 return "tag" === e.type || ("script" === e.type || "style" === e.type);
6608 }
6609 };
6610 }, {}]
6611 }, {}, [1])(1);
6612 /**
6613 * @param {Object} node
6614 * @return {?}
6615 */
6616 var create = function(node) {
6617 var element;
6618 switch(node.type) {
6619 case "script-text":
6620 return stringify("Encountered script-text node! WHAT DO!"), document.createTextNode(node.data);
6621 case "text":
6622 return document.createTextNode(node.data);
6623 case "comment":
6624 try {
6625 return document.createComment(node.data);
6626 } catch (ex) {
6627 return document.createComment("Malformed comment. " + ex.message);
6628 }
6629 ;
6630 case "directive":
6631 return document.createComment("Ignored directive from document.write stream.");
6632 case "tag":
6633 ;
6634 case "script":
6635 if (!node.attribs) {
6636 node.attribs = {};
6637 }
6638 var key;
6639 for (key in node.attribs) {
6640 node.attribs[key.toLowerCase()] = node.attribs[key];
6641 if (key.toLowerCase() !== key) {
6642 delete node.attribs[key];
6643 }
6644 }
6645 if (!("script" !== node.type.toLowerCase() && "script" !== node.name.toLowerCase())) {
6646 if ("src" in node.attribs) {
6647 node.attribs["data-rocketsrc"] = node.attribs.src;
6648 delete node.attribs.src;
6649 }
6650 /** @type {string} */
6651 node.attribs.type = "text/rocketscript";
6652 }
6653 ;
6654 default:
6655 /** @type {Element} */
6656 element = document.createElement(node.name);
6657 }
6658 return forEach(node.attribs, function(val, part) {
6659 if (/^id$|^src$/.test(part)) {
6660 /** @type {string} */
6661 element[part.toLowerCase()] = val;
6662 } else {
6663 if (/^class$/.test(part)) {
6664 /** @type {string} */
6665 element.className = val;
6666 } else {
6667 init(element, part, val);
6668 }
6669 }
6670 }), element;
6671 };
6672 /**
6673 * @param {string} nodeName
6674 * @param {string} evt
6675 * @return {?}
6676 */
6677 var parse = function(nodeName, evt) {
6678 var n = openImpliesClose;
6679 var nodeRules = n[nodeName.toLowerCase()];
6680 var parentRules = n[evt.toLowerCase()];
6681 return!(parentRules && (parentRules.exclusive && nodeName in parentRules.exclusive)) && !(parentRules && ("body" !== evt && (!(parentRules.inclusive && nodeName in parentRules.inclusive) && (nodeRules && (nodeRules.contentCategories && (parentRules.contentModel && ("empty" === parentRules.contentModel || !("transparent" === parentRules.contentModel || parentRules.contentModel in nodeRules.contentCategories))))))));
6682 };
6683 var openImpliesClose = {
6684 head : {
6685 contentCategories : {},
6686 contentModel : "metadata"
6687 },
6688 title : {
6689 contentCategories : {
6690 metadata : 1
6691 },
6692 contentModel : "text"
6693 },
6694 base : {
6695 contentCategories : {
6696 metadata : 1
6697 },
6698 contentModel : "empty"
6699 },
6700 link : {
6701 contentCategories : {
6702 metadata : 1
6703 },
6704 contentModel : "empty"
6705 },
6706 meta : {
6707 contentCategories : {
6708 metadata : 1
6709 },
6710 contentModel : "empty"
6711 },
6712 style : {
6713 contentCategories : {
6714 metadata : 1,
6715 flow : 1
6716 },
6717 contentModel : "text"
6718 },
6719 script : {
6720 contentCategories : {
6721 metadata : 1,
6722 flow : 1,
6723 phrasing : 1
6724 },
6725 contentModel : "text"
6726 },
6727 noscript : {
6728 contentCategories : {
6729 metadata : 1,
6730 flow : 1,
6731 phrasing : 1
6732 },
6733 contentModel : "transparent",
6734 exclusive : {
6735 noscript : "recursive"
6736 }
6737 },
6738 body : {
6739 contentCategories : {
6740 sectioning : 1
6741 },
6742 contentModel : "flow"
6743 },
6744 section : {
6745 contentCategories : {
6746 flow : 1,
6747 sectioning : 1
6748 },
6749 contentModel : "flow"
6750 },
6751 nav : {
6752 contentCategories : {
6753 flow : 1,
6754 sectioning : 1
6755 },
6756 contentModel : "flow"
6757 },
6758 article : {
6759 contentCategories : {
6760 flow : 1,
6761 sectioning : 1
6762 },
6763 contentModel : "flow"
6764 },
6765 aside : {
6766 contentCategories : {
6767 flow : 1,
6768 sectioning : 1
6769 },
6770 contentModel : "flow"
6771 },
6772 h1 : {
6773 contentCategories : {
6774 flow : 1,
6775 heading : 1
6776 },
6777 contentModel : "phrasing"
6778 },
6779 h2 : {
6780 contentCategories : {
6781 flow : 1,
6782 heading : 1
6783 },
6784 contentModel : "phrasing"
6785 },
6786 h3 : {
6787 contentCategories : {
6788 flow : 1,
6789 heading : 1
6790 },
6791 contentModel : "phrasing"
6792 },
6793 h4 : {
6794 contentCategories : {
6795 flow : 1,
6796 heading : 1
6797 },
6798 contentModel : "phrasing"
6799 },
6800 h5 : {
6801 contentCategories : {
6802 flow : 1,
6803 heading : 1
6804 },
6805 contentModel : "phrasing"
6806 },
6807 h6 : {
6808 contentCategories : {
6809 flow : 1,
6810 heading : 1
6811 },
6812 contentModel : "phrasing"
6813 },
6814 hgroup : {
6815 contentCategories : {
6816 flow : 1,
6817 heading : 1
6818 },
6819 contentModel : "empty",
6820 inclusive : {
6821 h1 : 1,
6822 h2 : 1,
6823 h3 : 1,
6824 h4 : 1,
6825 h5 : 1,
6826 h6 : 1
6827 }
6828 },
6829 header : {
6830 contentCategories : {
6831 flow : 1
6832 },
6833 contentModel : "flow",
6834 exclusive : {
6835 header : "recursive",
6836 footer : "recursive"
6837 }
6838 },
6839 footer : {
6840 contentCategories : {
6841 flow : 1
6842 },
6843 contentModel : "flow",
6844 exclusive : {
6845 header : "recursive",
6846 footer : "recursive"
6847 }
6848 },
6849 address : {
6850 contentCategories : {
6851 flow : 1
6852 },
6853 contentModel : "flow",
6854 exclusive : {
6855 address : "recursive",
6856 header : "recursive",
6857 footer : "recursive"
6858 }
6859 },
6860 p : {
6861 contentCategories : {
6862 flow : 1
6863 },
6864 contentModel : "phrasing"
6865 },
6866 hr : {
6867 contentCategories : {
6868 flow : 1
6869 },
6870 contentModel : "empty"
6871 },
6872 pre : {
6873 contentCategories : {
6874 flow : 1
6875 },
6876 contentModel : "phrasing"
6877 },
6878 blockquote : {
6879 contentCategories : {
6880 flow : 1,
6881 sectioning : 1
6882 },
6883 contentModel : "flow"
6884 },
6885 ol : {
6886 contentCategories : {
6887 flow : 1
6888 },
6889 contentModel : "empty",
6890 inclusive : {
6891 li : 1
6892 }
6893 },
6894 ul : {
6895 contentCategories : {
6896 flow : 1
6897 },
6898 contentModel : "flow",
6899 inclusive : {
6900 li : 1
6901 }
6902 },
6903 li : {
6904 contentCategories : {},
6905 contentModel : "flow"
6906 },
6907 dl : {
6908 contentCategories : {
6909 flow : 1
6910 },
6911 contentModel : "empty",
6912 inclusive : {
6913 dt : 1,
6914 dd : 1
6915 }
6916 },
6917 dt : {
6918 contentCategories : {},
6919 contentModel : "phrasing"
6920 },
6921 dd : {
6922 contentCategories : {},
6923 contentModel : "flow"
6924 },
6925 figure : {
6926 contentCategories : {
6927 flow : 1,
6928 sectioning : 1
6929 },
6930 contentModel : "flow",
6931 inclusive : {
6932 figcaption : 1
6933 }
6934 },
6935 figcaption : {
6936 contentCategories : {},
6937 contentModel : "flow"
6938 },
6939 div : {
6940 contentCategories : {
6941 flow : 1
6942 },
6943 contentModel : "flow"
6944 },
6945 a : {
6946 contentCategories : {
6947 flow : 1,
6948 phrasing : 1,
6949 interactive : 1
6950 },
6951 contentModel : "transparent",
6952 exclusive : {}
6953 },
6954 em : {
6955 contentCategories : {
6956 flow : 1,
6957 phrasing : 1
6958 },
6959 contentModel : "phrasing"
6960 },
6961 strong : {
6962 contentCategories : {
6963 flow : 1,
6964 phrasing : 1
6965 },
6966 contentModel : "phrasing"
6967 },
6968 small : {
6969 contentCategories : {
6970 flow : 1,
6971 phrasing : 1
6972 },
6973 contentModel : "phrasing"
6974 },
6975 s : {
6976 contentCategories : {
6977 flow : 1,
6978 phrasing : 1
6979 },
6980 contentModel : "phrasing"
6981 },
6982 cite : {
6983 contentCategories : {
6984 flow : 1,
6985 phrasing : 1
6986 },
6987 contentModel : "phrasing"
6988 },
6989 q : {
6990 contentCategories : {
6991 flow : 1,
6992 phrasing : 1
6993 },
6994 contentModel : "phrasing"
6995 },
6996 dfn : {
6997 contentCategories : {
6998 flow : 1,
6999 phrasing : 1
7000 },
7001 contentModel : "phrasing",
7002 exclusive : {
7003 dfn : "recursive"
7004 }
7005 },
7006 abbr : {
7007 contentCategories : {
7008 flow : 1,
7009 phrasing : 1
7010 },
7011 contentModel : "phrasing"
7012 },
7013 time : {
7014 contentCategories : {
7015 flow : 1,
7016 phrasing : 1
7017 },
7018 contentModel : "phrasing"
7019 },
7020 code : {
7021 contentCategories : {
7022 flow : 1,
7023 phrasing : 1
7024 },
7025 contentModel : "phrasing"
7026 },
7027 "var" : {
7028 contentCategories : {
7029 flow : 1,
7030 phrasing : 1
7031 },
7032 contentModel : "phrasing"
7033 },
7034 samp : {
7035 contentCategories : {
7036 flow : 1,
7037 phrasing : 1
7038 },
7039 contentModel : "phrasing"
7040 },
7041 kbd : {
7042 contentCategories : {
7043 flow : 1,
7044 phrasing : 1
7045 },
7046 contentModel : "phrasing"
7047 },
7048 sub : {
7049 contentCategories : {
7050 flow : 1,
7051 phrasing : 1
7052 },
7053 contentModel : "phrasing"
7054 },
7055 sup : {
7056 contentCategories : {
7057 flow : 1,
7058 phrasing : 1
7059 },
7060 contentModel : "phrasing"
7061 },
7062 i : {
7063 contentCategories : {
7064 flow : 1,
7065 phrasing : 1
7066 },
7067 contentModel : "phrasing"
7068 },
7069 b : {
7070 contentCategories : {
7071 flow : 1,
7072 phrasing : 1
7073 },
7074 contentModel : "phrasing"
7075 },
7076 mark : {
7077 contentCategories : {
7078 flow : 1,
7079 phrasing : 1
7080 },
7081 contentModel : "phrasing"
7082 },
7083 ruby : {
7084 contentCategories : {
7085 flow : 1,
7086 phrasing : 1
7087 },
7088 contentModel : "phrasing",
7089 inclusive : {
7090 rt : 1,
7091 rp : 1
7092 }
7093 },
7094 rt : {
7095 contentCategories : {},
7096 contentModel : "phrasing"
7097 },
7098 rp : {
7099 contentCategories : {},
7100 contentModel : "phrasing"
7101 },
7102 bdi : {
7103 contentCategories : {
7104 flow : 1,
7105 phrasing : 1
7106 },
7107 contentModel : "phrasing"
7108 },
7109 bdo : {
7110 contentCategories : {
7111 flow : 1,
7112 phrasing : 1
7113 },
7114 contentModel : "phrasing"
7115 },
7116 span : {
7117 contentCategories : {
7118 flow : 1,
7119 phrasing : 1
7120 },
7121 contentModel : "phrasing"
7122 },
7123 br : {
7124 contentCategories : {
7125 flow : 1,
7126 phrasing : 1
7127 },
7128 contentModel : "empty"
7129 },
7130 wbr : {
7131 contentCategories : {
7132 flow : 1,
7133 phrasing : 1
7134 },
7135 contentModel : "empty"
7136 },
7137 ins : {
7138 contentCategories : {
7139 flow : 1,
7140 phrasing : 1
7141 },
7142 contentModel : "transparent"
7143 },
7144 del : {
7145 contentCategories : {
7146 flow : 1,
7147 phrasing : 1
7148 },
7149 contentModel : "transparent"
7150 },
7151 img : {
7152 contentCategories : {
7153 flow : 1,
7154 phrasing : 1,
7155 embedded : 1
7156 },
7157 contentModel : "empty"
7158 },
7159 iframe : {
7160 contentCategories : {
7161 flow : 1,
7162 phrasing : 1,
7163 embedded : 1,
7164 interactive : 1
7165 },
7166 contentModel : "transparent"
7167 },
7168 embed : {
7169 contentCategories : {
7170 flow : 1,
7171 phrasing : 1,
7172 embedded : 1,
7173 interactive : 1
7174 },
7175 contentModel : "empty"
7176 },
7177 object : {
7178 contentCategories : {
7179 flow : 1,
7180 phrasing : 1,
7181 embedded : 1,
7182 interactive : 1
7183 },
7184 contentModel : "transparent",
7185 inclusive : {
7186 param : 1
7187 }
7188 },
7189 param : {
7190 contentCategories : {},
7191 contentModel : "empty"
7192 },
7193 video : {
7194 contentCategories : {
7195 flow : 1,
7196 phrasing : 1,
7197 embedded : 1
7198 },
7199 contentModel : "transparent"
7200 },
7201 audio : {
7202 contentCategories : {
7203 flow : 1,
7204 phrasing : 1,
7205 embedded : 1,
7206 interactive : 1
7207 },
7208 contentModel : "transparent"
7209 },
7210 source : {
7211 contentCategories : {},
7212 contentModel : "empty"
7213 },
7214 track : {
7215 contentCategories : {},
7216 contentModel : "empty"
7217 },
7218 canvas : {
7219 contentCategories : {
7220 flow : 1,
7221 phrasing : 1,
7222 embedded : 1
7223 },
7224 contentModel : "transparent"
7225 },
7226 map : {
7227 contentCategories : {
7228 flow : 1,
7229 phrasing : 1
7230 },
7231 contentModel : "transparent"
7232 },
7233 area : {
7234 contentCategories : {
7235 flow : 1,
7236 phrasing : 1
7237 },
7238 contentModel : "empty"
7239 },
7240 table : {
7241 contentCategories : {
7242 flow : 1
7243 },
7244 contentModel : "empty",
7245 inclusive : {
7246 caption : 1,
7247 colgroup : 1,
7248 thead : 1,
7249 tfoot : 1,
7250 tbody : 1,
7251 tr : 1
7252 }
7253 },
7254 caption : {
7255 contentCategories : {},
7256 contentModel : "flow",
7257 exclusive : {
7258 table : "recursive"
7259 }
7260 },
7261 colgroup : {
7262 contentCategories : {},
7263 contentModel : "empty",
7264 inclusive : {
7265 col : 1
7266 }
7267 },
7268 col : {
7269 contentCategories : {},
7270 contentModel : "empty"
7271 },
7272 tbody : {
7273 contentCategories : {},
7274 contentModel : "empty",
7275 inclusive : {
7276 tr : 1
7277 }
7278 },
7279 thead : {
7280 contentCategories : {},
7281 contentModel : "empty",
7282 inclusive : {
7283 tr : 1
7284 }
7285 },
7286 tfoot : {
7287 contentCategories : {},
7288 contentModel : "empty",
7289 inclusive : {
7290 tr : 1
7291 }
7292 },
7293 tr : {
7294 contentCategories : {},
7295 contentModel : "empty",
7296 inclusive : {
7297 td : 1,
7298 th : 1
7299 }
7300 },
7301 td : {
7302 contentCategories : {
7303 sectioning : 1
7304 },
7305 contentModel : "flow"
7306 },
7307 th : {
7308 contentCategories : {},
7309 contentModel : "phrasing"
7310 },
7311 form : {
7312 contentCategories : {
7313 flow : 1
7314 },
7315 contentModel : "flow",
7316 exclusive : {
7317 form : "recursive"
7318 }
7319 },
7320 fieldset : {
7321 contentCategories : {
7322 flow : 1,
7323 sectioning : 1
7324 },
7325 contentModel : "flow",
7326 inclusive : {
7327 legend : 1
7328 }
7329 },
7330 legend : {
7331 contentCategories : {},
7332 contentModel : "phrasing"
7333 },
7334 label : {
7335 contentCategories : {
7336 flow : 1,
7337 phrasing : 1,
7338 interactive : 1
7339 },
7340 contentModel : "phrasing"
7341 },
7342 input : {
7343 contentCategories : {
7344 flow : 1,
7345 phrasing : 1,
7346 interactive : 1
7347 },
7348 contentModel : "empty"
7349 },
7350 button : {
7351 contentCategories : {
7352 flow : 1,
7353 phrasing : 1,
7354 interactive : 1
7355 },
7356 contentModel : "phrasing"
7357 },
7358 select : {
7359 contentCategories : {
7360 flow : 1,
7361 phrasing : 1,
7362 interactive : 1
7363 },
7364 contentModel : "empty",
7365 inclusive : {
7366 option : 1,
7367 optgroup : 1
7368 }
7369 },
7370 datalist : {
7371 contentCategories : {
7372 flow : 1,
7373 phrasing : 1
7374 },
7375 contentModel : "phrasing",
7376 inclusive : {
7377 option : 1
7378 }
7379 },
7380 optgroup : {
7381 contentCategories : {},
7382 contentModel : "empty",
7383 inclusive : {
7384 option : 1
7385 }
7386 },
7387 option : {
7388 contentCategories : {},
7389 contentModel : "text"
7390 },
7391 textarea : {
7392 contentCategories : {
7393 flow : 1,
7394 phrasing : 1,
7395 interactive : 1
7396 },
7397 contentModel : "text"
7398 },
7399 keygen : {
7400 contentCategories : {
7401 flow : 1,
7402 phrasing : 1,
7403 interactive : 1
7404 },
7405 contentModel : "empty"
7406 },
7407 output : {
7408 contentCategories : {
7409 flow : 1,
7410 phrasing : 1
7411 },
7412 contentModel : "phrasing"
7413 },
7414 progress : {
7415 contentCategories : {
7416 flow : 1,
7417 phrasing : 1
7418 },
7419 contentModel : "phrasing",
7420 exclusive : {
7421 progress : "recursive"
7422 }
7423 },
7424 meter : {
7425 contentCategories : {
7426 flow : 1,
7427 phrasing : 1
7428 },
7429 contentModel : "phrasing",
7430 exclusive : {
7431 meter : "recursive"
7432 }
7433 },
7434 details : {
7435 contentCategories : {
7436 flow : 1,
7437 sectioning : 1,
7438 interactive : 1
7439 },
7440 contentModel : "flow",
7441 inclusive : {
7442 summary : 1
7443 }
7444 },
7445 summary : {
7446 contentCategories : {},
7447 contentModel : "phrasing"
7448 },
7449 command : {
7450 contentCategories : {
7451 metadata : 1,
7452 flow : 1,
7453 phrasing : 1
7454 },
7455 contentModel : "empty"
7456 },
7457 menu : {
7458 contentCategories : {
7459 flow : 1,
7460 interactive : 1
7461 },
7462 contentModel : "flow",
7463 inclusive : {
7464 li : 1
7465 }
7466 }
7467 };
7468 /**
7469 * @return {?}
7470 */
7471 var tryIt = function() {
7472 try {
7473 return!(!Object.defineProperty || !Object.getOwnPropertyDescriptor);
7474 } catch (t) {
7475 return false;
7476 }
7477 };
7478 /**
7479 * @return {?}
7480 */
7481 var definePropertyError = function() {
7482 try {
7483 return!(!document.__defineSetter__ || !document.__defineGetter__);
7484 } catch (t) {
7485 return false;
7486 }
7487 };
7488 /**
7489 * @param {Object} obj
7490 * @param {string} name
7491 * @param {?} descriptor
7492 * @return {undefined}
7493 */
7494 var get = function(obj, name, descriptor) {
7495 var getter = descriptor.get;
7496 var setter = descriptor.set;
7497 try {
7498 if (definePropertyError()) {
7499 if (getter) {
7500 obj.__defineGetter__(name, getter);
7501 }
7502 if (setter) {
7503 obj.__defineSetter__(name, setter);
7504 }
7505 } else {
7506 if (tryIt()) {
7507 Object.defineProperty(obj, name, descriptor);
7508 } else {
7509 callback("Warning: agent does not support property descriptor modifications.");
7510 }
7511 }
7512 } catch (ex) {
7513 stringify("Attempt to modify descriptor for property " + name + " failed. " + ex.message);
7514 }
7515 };
7516 /**
7517 * @param {?} o
7518 * @param {string} name
7519 * @return {?}
7520 */
7521 var defineProperty = function(o, name) {
7522 return definePropertyError() ? {
7523 get : o.__lookupGetter__(name),
7524 set : o.__lookupSetter__(name)
7525 } : tryIt() ? Object.getOwnPropertyDescriptor(o, name) : {};
7526 };
7527 /**
7528 * @param {string} value
7529 * @return {?}
7530 */
7531 var removeClass = function(value) {
7532 return "string" == typeof value ? value.trim ? value.trim() : value.replace(/(^\s*|\s*$)/g, "") : value;
7533 };
7534 var trim = (document.createElement("a"), function() {
7535 /** @type {Element} */
7536 var el = document.createElement("div");
7537 /** @type {DOMURL} */
7538 var Location = window.URL || window.webkitURL;
7539 /** @type {boolean} */
7540 var n = true;
7541 try {
7542 /** @type {boolean} */
7543 n = null != (new Location(window.location && window.location.href)).href;
7544 } catch (r) {
7545 /** @type {boolean} */
7546 n = false;
7547 }
7548 return n ? function(newHighlight) {
7549 return(new Location(newHighlight, document.baseURI || window.location && window.location.href)).href;
7550 } : function(pair) {
7551 return pair = pair.split("&").join("&").split("<").join("<").split("'").join("'"), el.innerHTML = '<a href="' + pair + '">x</a>', el.firstChild.href;
7552 };
7553 }());
7554 var DOMParser = function() {
7555 /**
7556 * @return {undefined}
7557 */
7558 function self() {
7559 /** @type {null} */
7560 this.boundary = null;
7561 /** @type {null} */
7562 this.boundaryChars = null;
7563 /** @type {null} */
7564 this.lookbehind = null;
7565 /** @type {number} */
7566 this.state = state.PARSER_UNINITIALIZED;
7567 /** @type {null} */
7568 this.index = null;
7569 /** @type {number} */
7570 this.flags = 0;
7571 }
7572 var state = {
7573 PARSER_UNINITIALIZED : 0,
7574 START : 1,
7575 START_BOUNDARY : 2,
7576 HEADER_FIELD_START : 3,
7577 HEADER_FIELD : 4,
7578 HEADER_VALUE_START : 5,
7579 HEADER_VALUE : 6,
7580 HEADER_VALUE_ALMOST_DONE : 7,
7581 HEADERS_ALMOST_DONE : 8,
7582 PART_DATA_START : 9,
7583 PART_DATA : 10,
7584 PART_END : 11,
7585 END : 12
7586 };
7587 var PART_BOUNDARY = {
7588 PART_BOUNDARY : 1,
7589 LAST_BOUNDARY : 2
7590 };
7591 return self.stateToString = function(value) {
7592 var property;
7593 for (property in state) {
7594 if (state.hasOwnProperty(property) && state[property] === value) {
7595 return property;
7596 }
7597 }
7598 }, self.prototype.initWithBoundary = function(str) {
7599 if (!str || /^(?![-0-9A-Za-z'()+_,./:=? ]{1,63}$)/.test(str)) {
7600 throw new TypeError("Invalid boundary");
7601 }
7602 /** @type {string} */
7603 this.boundary = "\r\n--" + str;
7604 /** @type {Array} */
7605 this.lookbehind = [];
7606 /** @type {number} */
7607 this.state = state.START;
7608 this.boundaryChars = {};
7609 /** @type {number} */
7610 var i = 0;
7611 for (;i < this.boundary.length;i++) {
7612 /** @type {boolean} */
7613 this.boundaryChars[this.boundary[i]] = true;
7614 }
7615 }, self.prototype.write = function(buffer) {
7616 var n;
7617 var dataCallback = once(function(name) {
7618 this[name + "Mark"] = i;
7619 }, this);
7620 var clear = once(function(name) {
7621 delete this[name + "Mark"];
7622 }, this);
7623 var callback = once(function(rgb, n, obj, dst) {
7624 if (obj === undefined || obj !== dst) {
7625 var nMod10 = "on" + rgb.substr(0, 1).toUpperCase() + rgb.substr(1);
7626 if (nMod10 in this) {
7627 this[nMod10](n, obj, dst);
7628 }
7629 }
7630 }, this);
7631 var mark = once(function(name, dataAndEvents) {
7632 /** @type {string} */
7633 var markSymbol = name + "Mark";
7634 if (markSymbol in this) {
7635 if (dataAndEvents) {
7636 callback(name, buffer, this[markSymbol], i);
7637 delete this[markSymbol];
7638 } else {
7639 callback(name, buffer, this[markSymbol], buffer.length);
7640 /** @type {number} */
7641 this[markSymbol] = 0;
7642 }
7643 }
7644 }, this);
7645 var bufferLength = buffer.length;
7646 /** @type {number} */
7647 var i = 0;
7648 var prevIndex = this.index;
7649 /** @type {number} */
7650 var boundaryEnd = this.boundary.length - 1;
7651 /** @type {number} */
7652 i = 0;
7653 for (;i < bufferLength;i++) {
7654 switch(n = buffer[i], this.state) {
7655 case state.PARSER_UNINITIALIZED:
7656 return i;
7657 case state.START:
7658 /** @type {number} */
7659 this.index = 0;
7660 this.state = state.START_BOUNDARY;
7661 case state.START_BOUNDARY:
7662 if (this.index === this.boundary.length - 2) {
7663 if ("-" === n) {
7664 this.flags |= PART_BOUNDARY.LAST_BOUNDARY;
7665 } else {
7666 if ("\r" !== n) {
7667 return i;
7668 }
7669 }
7670 this.index++;
7671 break;
7672 }
7673 if (this.index - 1 == this.boundary.length - 2) {
7674 if (this.flags & PART_BOUNDARY.LAST_BOUNDARY && "-" === n) {
7675 callback("end");
7676 this.state = state.END;
7677 /** @type {number} */
7678 this.flags = 0;
7679 } else {
7680 if (this.flags & PART_BOUNDARY.LAST_BOUNDARY || "\n" !== n) {
7681 return i;
7682 }
7683 /** @type {number} */
7684 this.index = 0;
7685 callback("partBegin");
7686 this.state = state.HEADER_FIELD_START;
7687 }
7688 break;
7689 }
7690 if (n !== this.boundary[this.index + 2]) {
7691 /** @type {number} */
7692 this.index = -2;
7693 }
7694 if (n === this.boundary[this.index + 2]) {
7695 this.index++;
7696 }
7697 break;
7698 case state.HEADER_FIELD_START:
7699 this.state = state.HEADER_FIELD;
7700 dataCallback("headerField");
7701 /** @type {number} */
7702 this.index = 0;
7703 case state.HEADER_FIELD:
7704 if ("\r" === n) {
7705 clear("headerField");
7706 this.state = state.HEADERS_ALMOST_DONE;
7707 break;
7708 }
7709 if (this.index++, "-" === n) {
7710 break;
7711 }
7712 if (":" === n) {
7713 if (1 === this.index) {
7714 return i;
7715 }
7716 mark("headerField", true);
7717 this.state = state.HEADER_VALUE_START;
7718 break;
7719 }
7720 break;
7721 case state.HEADER_VALUE_START:
7722 if (" " === n) {
7723 break;
7724 }
7725 dataCallback("headerValue");
7726 this.state = state.HEADER_VALUE;
7727 case state.HEADER_VALUE:
7728 if ("\r" === n) {
7729 mark("headerValue", true);
7730 callback("headerEnd");
7731 this.state = state.HEADER_VALUE_ALMOST_DONE;
7732 }
7733 break;
7734 case state.HEADER_VALUE_ALMOST_DONE:
7735 if ("\n" !== n) {
7736 return i;
7737 }
7738 this.state = state.HEADER_FIELD_START;
7739 break;
7740 case state.HEADERS_ALMOST_DONE:
7741 if ("\n" !== n) {
7742 return i;
7743 }
7744 callback("headersEnd");
7745 this.state = state.PART_DATA_START;
7746 break;
7747 case state.PART_DATA_START:
7748 this.state = state.PART_DATA;
7749 dataCallback("partData");
7750 case state.PART_DATA:
7751 if (prevIndex = this.index, 0 === this.index) {
7752 i += boundaryEnd;
7753 for (;i < buffer.length && !(buffer[i] in this.boundaryChars);) {
7754 i += this.boundary.length;
7755 }
7756 n = buffer[i -= boundaryEnd];
7757 }
7758 if (this.index < this.boundary.length) {
7759 if (this.boundary[this.index] === n) {
7760 if (0 === this.index) {
7761 mark("partData", true);
7762 }
7763 this.index++;
7764 } else {
7765 /** @type {number} */
7766 this.index = 0;
7767 }
7768 } else {
7769 if (this.index === this.boundary.length) {
7770 this.index++;
7771 if ("\r" === n) {
7772 this.flags |= PART_BOUNDARY.PART_BOUNDARY;
7773 } else {
7774 if ("-" === n) {
7775 this.flags |= PART_BOUNDARY.LAST_BOUNDARY;
7776 } else {
7777 /** @type {number} */
7778 this.index = 0;
7779 }
7780 }
7781 } else {
7782 if (this.index - 1 === this.boundary.length) {
7783 if (this.flags & PART_BOUNDARY.PART_BOUNDARY) {
7784 if (this.index = 0, "\n" === n) {
7785 this.flags &= ~PART_BOUNDARY.PART_BOUNDARY;
7786 callback("partEnd");
7787 callback("partBegin");
7788 this.state = state.HEADER_FIELD_START;
7789 break;
7790 }
7791 } else {
7792 if (this.flags & PART_BOUNDARY.LAST_BOUNDARY && "-" === n) {
7793 callback("partEnd");
7794 callback("end");
7795 this.state = state.END;
7796 /** @type {number} */
7797 this.flags = 0;
7798 } else {
7799 /** @type {number} */
7800 this.index = 0;
7801 }
7802 }
7803 }
7804 }
7805 }
7806 if (this.index > 0) {
7807 this.lookbehind[this.index - 1] = n;
7808 } else {
7809 if (prevIndex > 0) {
7810 callback("partData", this.lookbehind.join(""), 0, prevIndex);
7811 /** @type {number} */
7812 prevIndex = 0;
7813 dataCallback("partData");
7814 i--;
7815 }
7816 }
7817 ;
7818 case state.END:
7819 break;
7820 default:
7821 return i;
7822 }
7823 }
7824 return mark("headerField"), mark("headerValue"), mark("partData"), bufferLength;
7825 }, self.prototype.end = function() {
7826 /**
7827 * @param {?} self
7828 * @param {string} date
7829 * @return {undefined}
7830 */
7831 var callback = function(self, date) {
7832 var callbackSymbol = "on" + date.substr(0, 1).toUpperCase() + date.str(1);
7833 if (callbackSymbol in self) {
7834 self[callbackSymbol]();
7835 }
7836 };
7837 if (this.state === state.HEADER_FIELD_START && 0 === this.index || this.state === state.PART_DATA && this.index === this.boundary.length) {
7838 callback(this, "partEnd");
7839 callback(this, "end");
7840 } else {
7841 if (this.state !== state.END) {
7842 return new Error("MultipartParser.end(): stream ended unexpectedly, " + this);
7843 }
7844 }
7845 }, self.prototype.toString = function() {
7846 return "state = " + self.stateToString(this.state);
7847 }, self;
7848 }();
7849 /** @type {string} */
7850 var version = {
7851 version : "v0.11.8"
7852 }.version;
7853 /** @type {Array} */
7854 var axs = ["Microsoft.XMLHTTP", "MSXML2.XMLHTTP.3.0", "MSXML3.XMLHTTP", "MSXML2.XMLHTTP.6.0"];
7855 /**
7856 * @return {?}
7857 */
7858 var request = function() {
7859 if ("XMLHttpRequest" in window) {
7860 return new XMLHttpRequest;
7861 }
7862 for (;axs.length;) {
7863 try {
7864 return new window.ActiveXObject(axs[axs.length - 1]);
7865 } catch (t) {
7866 axs.pop();
7867 }
7868 }
7869 };
7870 var store = {};
7871 try {
7872 /** @type {(Storage|null)} */
7873 obj = window.localStorage;
7874 } catch (Ht) {
7875 obj = function() {
7876 /** @type {Array} */
7877 var result = [];
7878 var obj = {};
7879 var self = {};
7880 return self.getItem = function(key) {
7881 if (key in obj) {
7882 return result[obj[key]].value;
7883 }
7884 }, self.setItem = function(key, json) {
7885 var data = {};
7886 /** @type {string} */
7887 data.key = key;
7888 /** @type {Function} */
7889 data.value = json;
7890 if (key in obj) {
7891 result[obj[key]] = data;
7892 } else {
7893 /** @type {number} */
7894 obj[key] = (self.length = result.push(data)) - 1;
7895 }
7896 }, self.removeItem = function(name) {
7897 if (name in obj) {
7898 result.splice(obj[name], 1);
7899 }
7900 self.length = result.length;
7901 }, self.clear = function() {
7902 /** @type {Array} */
7903 result = [];
7904 obj = {};
7905 /** @type {number} */
7906 self.length = 0;
7907 }, self.toString = function() {
7908 return "[object FakeStorage]";
7909 }, self.key = function(index) {
7910 return result[index].key;
7911 }, self.each = function(iterator) {
7912 return forEach(obj, iterator);
7913 }, self.length = 0, self;
7914 }();
7915 }
7916 /**
7917 * @param {?} val
7918 * @param {Object} args
7919 * @return {?}
7920 */
7921 var update = function(val, args) {
7922 var result;
7923 try {
7924 result = obj[val].apply(obj, args);
7925 } catch (Ht) {
7926 store.purge();
7927 try {
7928 result = obj[val].apply(obj, args);
7929 } catch (r) {
7930 stringify("Storage is full and purging did not free up enough space.");
7931 }
7932 }
7933 return result;
7934 };
7935 call(["key", "getItem", "setItem", "removeItem", "clear", "toString"], function(method) {
7936 /**
7937 * @return {?}
7938 */
7939 store[method] = function() {
7940 return update(method, arguments);
7941 };
7942 });
7943 /**
7944 * @param {Function} iterator
7945 * @return {?}
7946 */
7947 store.each = function(iterator) {
7948 if ("function" == typeof obj.each) {
7949 return obj.each(iterator);
7950 }
7951 if (obj.length) {
7952 /** @type {number} */
7953 var index = 0;
7954 for (;index < obj.length;index++) {
7955 iterator(obj.key(index), index);
7956 }
7957 }
7958 };
7959 /**
7960 * @return {undefined}
7961 */
7962 store.purge = function() {
7963 var LEVEL_COND = param;
7964 /** @type {number} */
7965 var e = +new Date;
7966 store.each(function(key) {
7967 /** @type {boolean} */
7968 var r = false;
7969 if (/^CLOUDFLARE::/.test(key) && "JSON" in window) {
7970 try {
7971 /** @type {*} */
7972 var o = JSON.parse(store.getItem(key));
7973 } catch (Ht) {
7974 callback("Purging corrupted entity from cache: " + key);
7975 /** @type {boolean} */
7976 r = true;
7977 }
7978 if (o) {
7979 if (LEVEL_COND && o.stime <= LEVEL_COND || o.version !== version) {
7980 callback("Purging outdated entity from cache: " + key);
7981 /** @type {boolean} */
7982 r = true;
7983 } else {
7984 if (o.ctime + o.ttl < e) {
7985 callback("Purging cache-expired entity from cache: " + key);
7986 /** @type {boolean} */
7987 r = true;
7988 }
7989 }
7990 }
7991 try {
7992 if (r) {
7993 store.removeItem(key);
7994 }
7995 } catch (Ht) {
7996 }
7997 }
7998 });
7999 };
8000 var out;
8001 /**
8002 * @param {string} element
8003 * @return {?}
8004 */
8005 var requestAnimationFrame = function(element) {
8006 return "CLOUDFLARE::" + element;
8007 };
8008 /** @type {Function} */
8009 var countComplete = "JSON" in window ? function(object) {
8010 var id = requestAnimationFrame(object.url);
8011 try {
8012 store.setItem(id, JSON.stringify(object));
8013 } catch (ex) {
8014 stringify("Failed to store item " + id + ". " + ex.message);
8015 }
8016 } : function() {
8017 };
8018 var memory = {};
8019 var defers = {};
8020 /** @type {number} */
8021 var bt = 0;
8022 /** @type {RegExp} */
8023 var isint = /^https?:\/\/.*?\.?(livefyre\.com\/|api\.stripe\.com|api\.solvemedia\.com\/papi\/_challenge\.js|in\.getclicky\.com|win\.staticstuff\.net|www-connecting\.com|secure\.livechatinc\.com)/;
8024 /** @type {function (string): ?} */
8025 var resolve = HTMLEvents < 9 || (wrap < 3.3 || cb < 9.3) ? (window.__cfEvalResults = {}, window.__cfCodeToEval = {}, function(o) {
8026 var src;
8027 var script = _createElement("script");
8028 var num = t();
8029 /** @type {string} */
8030 var i = "__eval#" + num;
8031 /** @type {string} */
8032 var name = "__result#" + num;
8033 var head = document.getElementsByTagName("head")[0];
8034 return window.__cfCodeToEval[i] = o, script.type = "text/javascript", script.text = "__cfEvalResults['" + name + "']=eval(__cfCodeToEval['" + i + "']);", head.insertBefore(script, head.firstChild), head.removeChild(script), src = window.__cfCodeToEval[name], delete window.__cfCodeToEval[i], delete window.__cfEvalResults[name], src;
8035 }) : function(result) {
8036 return function() {
8037 return(0, eval)(result);
8038 }.call(window);
8039 };
8040 /**
8041 * @param {string} property
8042 * @return {?}
8043 */
8044 var getCallerInfo = function(property) {
8045 return function(o) {
8046 return{
8047 /**
8048 * @param {(number|string)} value
8049 * @return {undefined}
8050 */
8051 set : function(value) {
8052 o[property] = parseColor(value);
8053 },
8054 /**
8055 * @return {?}
8056 */
8057 get : function() {
8058 return walk(o[property]);
8059 }
8060 };
8061 };
8062 };
8063 /**
8064 * @param {string} name
8065 * @return {?}
8066 */
8067 var fieldPat = function(name) {
8068 return function(target) {
8069 return function() {
8070 return toArray(target[name].apply(target, arguments), walk);
8071 };
8072 };
8073 };
8074 /**
8075 * @param {string} name
8076 * @return {?}
8077 */
8078 var domChanger = function(name) {
8079 return function(old) {
8080 return function(rgb, walkers) {
8081 var src = old[name](parseColor(rgb), parseColor(walkers));
8082 return src && walk(src);
8083 };
8084 };
8085 };
8086 var options = {
8087 insertBefore : domChanger("insertBefore"),
8088 appendChild : domChanger("appendChild"),
8089 replaceChild : domChanger("replaceChild"),
8090 removeChild : domChanger("removeChild"),
8091 getElementsByTagName : fieldPat("getElementsByTagName"),
8092 getElementsByClassName : fieldPat("getElementsByClassName"),
8093 firstChild : getCallerInfo("firstChild"),
8094 lastChild : getCallerInfo("lastChild"),
8095 nextSibling : getCallerInfo("nextSibling"),
8096 previousSibling : getCallerInfo("previousSibling"),
8097 parentNode : getCallerInfo("parentNode"),
8098 /**
8099 * @param {Node} node
8100 * @return {?}
8101 */
8102 childNodes : function(node) {
8103 return{
8104 /**
8105 * @param {Array} ps
8106 * @return {undefined}
8107 */
8108 set : function(ps) {
8109 /** @type {Array} */
8110 node.childNodes = ps;
8111 },
8112 /**
8113 * @return {?}
8114 */
8115 get : function() {
8116 return toArray(node.childNodes, walk);
8117 }
8118 };
8119 }
8120 };
8121 var oldconfig = extend(extend({}, options), {
8122 /**
8123 * @param {Element} element
8124 * @return {?}
8125 */
8126 type : function(element) {
8127 return{
8128 /**
8129 * @return {?}
8130 */
8131 get : function() {
8132 var value = getAttribute(element, "type");
8133 return "text/rocketscript" === value ? "text/javascript" : value;
8134 },
8135 /**
8136 * @param {(number|string)} next
8137 * @return {undefined}
8138 */
8139 set : function(next) {
8140 init(element, "type", next);
8141 }
8142 };
8143 },
8144 /**
8145 * @param {Element} img
8146 * @return {?}
8147 */
8148 src : function(img) {
8149 return{
8150 /**
8151 * @return {?}
8152 */
8153 get : function() {
8154 var src = $(img, "rocketsrc");
8155 return src ? trim(src) : img.src;
8156 },
8157 /**
8158 * @param {string} value
8159 * @return {undefined}
8160 */
8161 set : function(value) {
8162 init(img, "type", "text/javascript");
8163 /** @type {string} */
8164 img.src = value;
8165 }
8166 };
8167 },
8168 /**
8169 * @param {Element} node
8170 * @return {?}
8171 */
8172 hasAttribute : function(node) {
8173 return function(attribute) {
8174 return "src" === attribute ? !!$(node, "rocketsrc") : node.hasAttribute(attribute);
8175 };
8176 },
8177 /**
8178 * @param {Element} node
8179 * @return {?}
8180 */
8181 getAttribute : function(node) {
8182 return function(string) {
8183 return "src" === string ? $(node, "rocketsrc") : node.getAttribute(string);
8184 };
8185 }
8186 });
8187 /**
8188 * @param {?} src
8189 * @return {?}
8190 */
8191 var require = function(src) {
8192 return function(exports) {
8193 var obj = {
8194 isProxyNode : true,
8195 proxiedNode : exports
8196 };
8197 var key;
8198 for (key in exports) {
8199 !function(opts, key) {
8200 var current = !!src[key] && src[key](exports);
8201 if ("function" == typeof opts) {
8202 obj[key] = current || function() {
8203 return exports[key].apply(exports, arguments);
8204 };
8205 } else {
8206 get(obj, key, {
8207 get : current.get || function() {
8208 return exports[key];
8209 },
8210 set : current.set || function(val) {
8211 /** @type {number} */
8212 exports[key] = val;
8213 }
8214 });
8215 }
8216 }(exports[key], key);
8217 }
8218 return obj;
8219 };
8220 };
8221 var move = require(options);
8222 var filter = require(oldconfig);
8223 var f = require({});
8224 /**
8225 * @param {Node} source
8226 * @return {?}
8227 */
8228 var walk = function(source) {
8229 return source ? "nodeName" in source ? 8 == +HTMLEvents || (!source || source.isProxyNode) ? source : "SCRIPT" === source.nodeName ? filter(source) : move(source) : f(source) : source;
8230 };
8231 /**
8232 * @param {string} obj
8233 * @return {?}
8234 */
8235 var parseColor = function(obj) {
8236 return obj && obj.isProxyNode ? obj.proxiedNode : obj;
8237 };
8238 if (wrap) {
8239 if ("Node" in window) {
8240 call(["appendChild", "insertBefore", "replaceChild", "removeChild"], function(name) {
8241 var b = Element.prototype[name];
8242 /**
8243 * @param {Text} start
8244 * @param {Text} end
8245 * @return {?}
8246 */
8247 Node.prototype[name] = function(start, end) {
8248 return start = parseColor(start), end = parseColor(end), b.call(this, start, end);
8249 };
8250 });
8251 }
8252 }
8253 callback("Capturing the window and document, and gathering scripts.");
8254 var that = function() {
8255 var b = function() {
8256 var interval;
8257 /**
8258 * @return {?}
8259 */
8260 var scan = function() {
8261 /** @type {number} */
8262 var index = 0;
8263 /** @type {Array} */
8264 var rst = [];
8265 for (;tags.length > index;) {
8266 var elem = tags[index];
8267 var $elem = $(elem, "rocketoptimized");
8268 var q = getAttribute(elem, "type");
8269 if ($elem || "text/rocketscript" !== q) {
8270 index++;
8271 } else {
8272 rst[rst.push(run(elem, item)) - 1].bookmark();
8273 }
8274 }
8275 return obj = rst.length ? 0 : obj + 1, rst;
8276 };
8277 /** @type {NodeList} */
8278 var tags = document.getElementsByTagName("script", true);
8279 /** @type {number} */
8280 var obj = 0;
8281 /**
8282 * @return {undefined}
8283 */
8284 var fail = function() {
8285 stringify("Scanner called empty script handler!");
8286 };
8287 var timer = {
8288 /**
8289 * @return {undefined}
8290 */
8291 scan : function() {
8292 callback("Scanning for scripts.");
8293 var ex = scan();
8294 if (ex.length) {
8295 fail(ex);
8296 }
8297 },
8298 /**
8299 * @return {undefined}
8300 */
8301 start : function() {
8302 if (!interval) {
8303 (function check() {
8304 timer.scan();
8305 if (obj < 50) {
8306 /** @type {number} */
8307 interval = setTimeout(check, 25);
8308 } else {
8309 timer.stop();
8310 }
8311 })();
8312 }
8313 },
8314 /**
8315 * @return {undefined}
8316 */
8317 stop : function() {
8318 if (interval) {
8319 clearInterval(interval);
8320 }
8321 timer.scan();
8322 interval = undefined;
8323 },
8324 /**
8325 * @param {Function} i
8326 * @return {undefined}
8327 */
8328 setScriptHandler : function(i) {
8329 /** @type {Function} */
8330 fail = i;
8331 }
8332 };
8333 return promise.then(function() {
8334 callback("Document fully loaded.");
8335 }), timer;
8336 }();
8337 /** @type {Array} */
8338 var ret = [];
8339 /** @type {Array} */
8340 var callbacks = [];
8341 /** @type {null} */
8342 var result = null;
8343 /** @type {boolean} */
8344 var getActivated = false;
8345 var promise = Q.ref();
8346 /**
8347 * @return {?}
8348 */
8349 var getNext = function() {
8350 return callback("Queueing " + ret.length + " scripts for execution."), call(ret, function(subKey) {
8351 promise = promise.then(function() {
8352 return(result = subKey).execute();
8353 });
8354 }), ret = [], promise;
8355 };
8356 var item = {
8357 /**
8358 * @param {?} func
8359 * @return {undefined}
8360 */
8361 pushPostExecuteHandler : function(func) {
8362 callbacks.push(func);
8363 },
8364 /**
8365 * @return {?}
8366 */
8367 execute : function() {
8368 return getActivated = true, b.scan(), getNext().then(function() {
8369 if (ret.length) {
8370 return item.execute();
8371 }
8372 if (callbacks.length) {
8373 call(callbacks, function(fn) {
8374 try {
8375 fn.call(window);
8376 } catch (ex) {
8377 stringify("Post Execute Handler failed: " + ex.message);
8378 }
8379 });
8380 /** @type {Array} */
8381 callbacks = [];
8382 }
8383 }).then(function() {
8384 /** @type {number} */
8385 var poll = setInterval(function() {
8386 if (ret.length) {
8387 clearInterval(poll);
8388 item.execute();
8389 }
8390 }, 250);
8391 });
8392 },
8393 /**
8394 * @param {?} key
8395 * @return {undefined}
8396 */
8397 pushScript : function(key) {
8398 ret.push(key);
8399 },
8400 /**
8401 * @return {?}
8402 */
8403 getActivated : function() {
8404 return getActivated;
8405 },
8406 /**
8407 * @param {?} item
8408 * @return {undefined}
8409 */
8410 setExecutingScript : function(item) {
8411 if (item) {
8412 result = item;
8413 }
8414 },
8415 /**
8416 * @return {?}
8417 */
8418 getExecutingScript : function() {
8419 return result;
8420 }
8421 };
8422 return b.setScriptHandler(function(elems) {
8423 ret = ret.concat(elems);
8424 }), b.start(), item;
8425 }();
8426 var page = function(method) {
8427 var e;
8428 /** @type {HTMLDocument} */
8429 var a = document;
8430 /** @type {boolean} */
8431 var r = true;
8432 /** @type {string} */
8433 var gReadyState = "loading";
8434 var parser = new Parser(new Scanner(function(m1, nodes) {
8435 if (m1) {
8436 return stringify("The parser experienced an error. " + m1.message);
8437 }
8438 if (nodes.length) {
8439 method.getExecutingScript().after(nodes);
8440 }
8441 }, function(area) {
8442 if (!area.parent) {
8443 var nodes = this.dom.splice(indexOfBodyArea(this.dom, area));
8444 method.getExecutingScript().after(nodes);
8445 }
8446 }), {
8447 decodeEntities : true
8448 });
8449 /**
8450 * @param {string} data
8451 * @return {undefined}
8452 */
8453 var write = function(data) {
8454 if ("string" != typeof data) {
8455 /** @type {string} */
8456 data = "" + data;
8457 }
8458 callback("Appending to document.write buffer: \n" + data);
8459 parser.write(data);
8460 };
8461 /**
8462 * @param {Error} type
8463 * @param {boolean} info
8464 * @return {?}
8465 */
8466 var process = function(type, info) {
8467 var result = self.getNativeMethod("getElementsByTagName").call(a, type);
8468 return callback("Looking up elements of type " + type + (info ? ", but overriding script introspection support" : "")), info || !/^script$/i.test(type) ? result : toArray(result, walk);
8469 };
8470 /**
8471 * @param {string} task
8472 * @return {?}
8473 */
8474 var build = function(task) {
8475 /** @type {Array} */
8476 var arr = [];
8477 return call(task.split(","), function(isXML) {
8478 var nparsed;
8479 var chunk = removeClass(isXML);
8480 arr.push(chunk);
8481 if (nparsed = /(.*)\[(src.*)\]/.exec(chunk)) {
8482 arr.push(nparsed[1] + "[data-rocket" + nparsed[2] + "]");
8483 }
8484 }), arr;
8485 };
8486 var self = remove(a, method);
8487 var child = remove(a.documentElement, method);
8488 return extend(self, {
8489 /**
8490 * @return {undefined}
8491 */
8492 ready : function() {
8493 e = document.getElementsByTagName("body")[0];
8494 /** @type {string} */
8495 gReadyState = "complete";
8496 /** @type {boolean} */
8497 r = false;
8498 self.fireEvent("DOMContentLoaded");
8499 self.fireEvent("readystatechange");
8500 },
8501 /** @type {function (string): undefined} */
8502 write : write,
8503 /**
8504 * @return {undefined}
8505 */
8506 flush : function() {
8507 parser.done();
8508 parser.reset();
8509 },
8510 /**
8511 * @return {?}
8512 */
8513 getParser : function() {
8514 return parser;
8515 }
8516 }), self.wrapNativeMethod("write", function(data) {
8517 if (data) {
8518 write(data);
8519 }
8520 }), self.wrapNativeMethod("writeln", function(msg) {
8521 if (msg) {
8522 write(msg + "\n");
8523 }
8524 }), self.wrapNativeMethod("open", function() {
8525 callback("Ignoring document.open..");
8526 }), self.wrapNativeMethod("close", function() {
8527 callback("Ignoring document.close..");
8528 }), self.wrapNativeMethod("createElement", function(fileContents) {
8529 var script = _createElement(fileContents);
8530 return "script" === fileContents && (script = bind(script, method).getTarget()), script;
8531 }), self.wrapNativeMethod("getElementsByTagName", process), child.wrapNativeMethod("getElementsByTagName", process), self.wrapNativeMethod("getElementById", function(type) {
8532 var node = self.getNativeMethod("getElementById").call(a, type);
8533 return node && (node.nodeName && "script" === node.nodeName.toLowerCase()) ? walk(node) : node;
8534 }), self.wrapNativeMethod("getElementsByClassName", function(cycle) {
8535 /** @type {Array} */
8536 var parent = [];
8537 return call(self.getNativeMethod("getElementsByClassName").call(a, cycle), function(t, key) {
8538 if (t) {
8539 if (t.nodeName) {
8540 if ("script" === t.nodeName.toLowerCase()) {
8541 t = walk(t);
8542 }
8543 }
8544 }
8545 /** @type {Node} */
8546 parent[key] = t;
8547 }), parent;
8548 }), self.wrapNativeMethod("documentElement.doScroll", function() {
8549 if (r) {
8550 throw "The data necessary to complete this operation is not yet available.";
8551 }
8552 self.getNativeMethod("documentElement.doScroll").apply(this, arguments);
8553 }), self.wrapNativeProperty("readyState", function() {
8554 return gReadyState;
8555 }), self.wrapNativeMethod("querySelector", function(name) {
8556 var elem = build(name).join(",");
8557 var target = self.getNativeMethod("querySelector").call(a, elem);
8558 return target && (target.nodeName && "script" === target.nodeName.toLowerCase()) ? walk(target) : target;
8559 }), self.wrapNativeMethod("querySelectorAll", function(name) {
8560 var cycle = build(name).join(",");
8561 return toArray(self.getNativeMethod("querySelectorAll").call(a, cycle), function(child) {
8562 return child && (child.nodeName && "script" === child.nodeName.toLowerCase()) ? walk(child) : child;
8563 });
8564 }), self.deferEvent("DOMContentLoaded"), self.deferEvent("readystatechange"), getter(self), self;
8565 }(that);
8566 var exports = function(method) {
8567 /** @type {Window} */
8568 var obj = window;
8569 var self = remove(obj, method);
8570 return extend(self, {
8571 /**
8572 * @param {?} callback
8573 * @return {undefined}
8574 */
8575 whenLoaded : function(callback) {
8576 if ("complete" === document.readyState) {
8577 callback();
8578 } else {
8579 if (self.getNativeMethod("addEventListener")) {
8580 self.getNativeMethod("addEventListener").call(obj, "load", callback, true);
8581 } else {
8582 self.getNativeMethod("attachEvent")("onload", callback);
8583 }
8584 }
8585 },
8586 /**
8587 * @return {undefined}
8588 */
8589 load : function() {
8590 self.fireEvent("load");
8591 }
8592 }), self.wrapNativeMethod("getComputedStyle", function(type, graphics) {
8593 return type.isProxyNode && (type = type.proxiedNode), self.getNativeMethod("getComputedStyle").call(this, type, graphics);
8594 }), self.deferEvent("load"), self;
8595 }(that);
8596 var invokeDfd = Q.defer();
8597 !function() {
8598 /** @type {boolean} */
8599 var orig = false;
8600 /**
8601 * @param {Event} event
8602 * @return {undefined}
8603 */
8604 var handler = function(event) {
8605 orig = event.shiftKey;
8606 orig = orig || event.ctrlKey;
8607 };
8608 on(document, "keydown", handler);
8609 on(document, "keyup", handler);
8610 on(window, "unload", function() {
8611 if (orig) {
8612 try {
8613 var name;
8614 /** @type {number} */
8615 var i = 0;
8616 for (;i < store.length;i++) {
8617 if (!(name = store.key[i]).indexOf("CLOUDFLARE")) {
8618 store.removeItem(name);
8619 }
8620 }
8621 } catch (Ht) {
8622 }
8623 }
8624 });
8625 }();
8626 /**
8627 * @param {Function} fnc
8628 * @return {undefined}
8629 */
8630 var defer = function(fnc) {
8631 setTimeout(fnc, 0);
8632 };
8633 window.__cfRl = {
8634 /**
8635 * @param {Function} name
8636 * @param {?} context
8637 * @return {undefined}
8638 */
8639 r : function(name, context) {
8640 if ("function" == typeof name) {
8641 that.pushPostExecuteHandler(once(name, context));
8642 }
8643 },
8644 done : invokeDfd.promise
8645 };
8646 promise.then(function() {
8647 return callback("Launching scripts."), that.execute().then(defer(function() {
8648 return callback("Firing deferred ready event."), page.ready(), that.execute().then(defer(function() {
8649 return callback("Firing deferred load event."), exports.load(), that.execute().then(defer(function() {
8650 var dig;
8651 if (window.Modernizr) {
8652 if (window.console) {
8653 if ((dig = window.Modernizr._version.split("."))[0] < 2 || 2 == +dig[0] && dig[1] < 6) {
8654 window.console.warn("Modernizr " + dig.join(".") + " detected. This version is known to cause issues with async JavaScript loaders. Please upgrade to at least 2.6: http://modernizr.com/");
8655 }
8656 }
8657 }
8658 callback("Fin.");
8659 invokeDfd.resolve();
8660 }));
8661 }));
8662 }));
8663 });
8664}();