worker-html-ea26ed95d6a1d2680…6c60855e7a757a887415f4a9cce510def5d75db0.js

js getdata.io collected 2026-09-24 11:30:51 UTC 316,131 bytes, 10,922 lines download raw bytes

1"no use strict";
2!(function(window) {
3if (typeof window.window != "undefined" && window.document)
4    return;
5if (window.require && window.define)
6    return;
7
8if (!window.console) {
9    window.console = function() {
10        var msgs = Array.prototype.slice.call(arguments, 0);
11        postMessage({type: "log", data: msgs});
12    };
13    window.console.error =
14    window.console.warn = 
15    window.console.log =
16    window.console.trace = window.console;
17}
18window.window = window;
19window.ace = window;
20
21window.onerror = function(message, file, line, col, err) {
22    postMessage({type: "error", data: {
23        message: message,
24        data: err.data,
25        file: file,
26        line: line, 
27        col: col,
28        stack: err.stack
29    }});
30};
31
32window.normalizeModule = function(parentId, moduleName) {
33    // normalize plugin requires
34    if (moduleName.indexOf("!") !== -1) {
35        var chunks = moduleName.split("!");
36        return window.normalizeModule(parentId, chunks[0]) + "!" + window.normalizeModule(parentId, chunks[1]);
37    }
38    // normalize relative requires
39    if (moduleName.charAt(0) == ".") {
40        var base = parentId.split("/").slice(0, -1).join("/");
41        moduleName = (base ? base + "/" : "") + moduleName;
42        
43        while (moduleName.indexOf(".") !== -1 && previous != moduleName) {
44            var previous = moduleName;
45            moduleName = moduleName.replace(/^\.\//, "").replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");
46        }
47    }
48    
49    return moduleName;
50};
51
52window.require = function require(parentId, id) {
53    if (!id) {
54        id = parentId;
55        parentId = null;
56    }
57    if (!id.charAt)
58        throw new Error("worker.js require() accepts only (parentId, id) as arguments");
59
60    id = window.normalizeModule(parentId, id);
61
62    var module = window.require.modules[id];
63    if (module) {
64        if (!module.initialized) {
65            module.initialized = true;
66            module.exports = module.factory().exports;
67        }
68        return module.exports;
69    }
70   
71    if (!window.require.tlns)
72        return console.log("unable to load " + id);
73    
74    var path = resolveModuleId(id, window.require.tlns);
75    if (path.slice(-3) != ".js") path += ".js";
76    
77    window.require.id = id;
78    window.require.modules[id] = {}; // prevent infinite loop on broken modules
79    importScripts(path);
80    return window.require(parentId, id);
81};
82function resolveModuleId(id, paths) {
83    var testPath = id, tail = "";
84    while (testPath) {
85        var alias = paths[testPath];
86        if (typeof alias == "string") {
87            return alias + tail;
88        } else if (alias) {
89            return  alias.location.replace(/\/*$/, "/") + (tail || alias.main || alias.name);
90        } else if (alias === false) {
91            return "";
92        }
93        var i = testPath.lastIndexOf("/");
94        if (i === -1) break;
95        tail = testPath.substr(i) + tail;
96        testPath = testPath.slice(0, i);
97    }
98    return id;
99}
100window.require.modules = {};
101window.require.tlns = {};
102
103window.define = function(id, deps, factory) {
104    if (arguments.length == 2) {
105        factory = deps;
106        if (typeof id != "string") {
107            deps = id;
108            id = window.require.id;
109        }
110    } else if (arguments.length == 1) {
111        factory = id;
112        deps = [];
113        id = window.require.id;
114    }
115    
116    if (typeof factory != "function") {
117        window.require.modules[id] = {
118            exports: factory,
119            initialized: true
120        };
121        return;
122    }
123
124    if (!deps.length)
125        // If there is no dependencies, we inject "require", "exports" and
126        // "module" as dependencies, to provide CommonJS compatibility.
127        deps = ["require", "exports", "module"];
128
129    var req = function(childId) {
130        return window.require(id, childId);
131    };
132
133    window.require.modules[id] = {
134        exports: {},
135        factory: function() {
136            var module = this;
137            var returnExports = factory.apply(this, deps.slice(0, factory.length).map(function(dep) {
138                switch (dep) {
139                    // Because "require", "exports" and "module" aren't actual
140                    // dependencies, we must handle them seperately.
141                    case "require": return req;
142                    case "exports": return module.exports;
143                    case "module":  return module;
144                    // But for all other dependencies, we can just go ahead and
145                    // require them.
146                    default:        return req(dep);
147                }
148            }));
149            if (returnExports)
150                module.exports = returnExports;
151            return module;
152        }
153    };
154};
155window.define.amd = {};
156require.tlns = {};
157window.initBaseUrls  = function initBaseUrls(topLevelNamespaces) {

158    for (var i in topLevelNamespaces)
159        require.tlns[i] = topLevelNamespaces[i];
160};
161
162window.initSender = function initSender() {
163
164    var EventEmitter = window.require("ace/lib/event_emitter").EventEmitter;
165    var oop = window.require("ace/lib/oop");
166    
167    var Sender = function() {};
168    
169    (function() {
170        
171        oop.implement(this, EventEmitter);
172                
173        this.callback = function(data, callbackId) {
174            postMessage({
175                type: "call",
176                id: callbackId,
177                data: data
178            });
179        };
180    
181        this.emit = function(name, data) {
182            postMessage({
183                type: "event",
184                name: name,
185                data: data
186            });
187        };
188        
189    }).call(Sender.prototype);
190    
191    return new Sender();
192};
193
194var main = window.main = null;
195var sender = window.sender = null;
196
197window.onmessage = function(e) {
198    var msg = e.data;
199    if (msg.event && sender) {
200        sender._signal(msg.event, msg.data);
201    }
202    else if (msg.command) {
203        if (main[msg.command])
204            main[msg.command].apply(main, msg.args);
205        else if (window[msg.command])
206            window[msg.command].apply(window, msg.args);
207        else
208            throw new Error("Unknown command:" + msg.command);
209    }
210    else if (msg.init) {
211        window.initBaseUrls(msg.tlns);
212        sender = window.sender = window.initSender();
213        var clazz = require(msg.module)[msg.classname];
214        main = window.main = new clazz(sender);
215    }
216};
217})(this);
218
219define("ace/lib/oop",[], function(require, exports, module) {
220"use strict";
221
222exports.inherits = function(ctor, superCtor) {
223    ctor.super_ = superCtor;
224    ctor.prototype = Object.create(superCtor.prototype, {
225        constructor: {
226            value: ctor,
227            enumerable: false,
228            writable: true,
229            configurable: true
230        }
231    });
232};
233
234exports.mixin = function(obj, mixin) {
235    for (var key in mixin) {
236        obj[key] = mixin[key];
237    }
238    return obj;
239};
240
241exports.implement = function(proto, mixin) {
242    exports.mixin(proto, mixin);
243};
244
245});
246
247define("ace/lib/lang",[], function(require, exports, module) {
248"use strict";
249
250exports.last = function(a) {
251    return a[a.length - 1];
252};
253
254exports.stringReverse = function(string) {
255    return string.split("").reverse().join("");
256};
257
258exports.stringRepeat = function (string, count) {
259    var result = '';
260    while (count > 0) {
261        if (count & 1)
262            result += string;
263
264        if (count >>= 1)
265            string += string;
266    }
267    return result;
268};
269
270var trimBeginRegexp = /^\s\s*/;
271var trimEndRegexp = /\s\s*$/;
272
273exports.stringTrimLeft = function (string) {
274    return string.replace(trimBeginRegexp, '');
275};
276
277exports.stringTrimRight = function (string) {
278    return string.replace(trimEndRegexp, '');
279};
280
281exports.copyObject = function(obj) {
282    var copy = {};
283    for (var key in obj) {
284        copy[key] = obj[key];
285    }
286    return copy;
287};
288
289exports.copyArray = function(array){
290    var copy = [];
291    for (var i=0, l=array.length; i<l; i++) {
292        if (array[i] && typeof array[i] == "object")
293            copy[i] = this.copyObject(array[i]);
294        else 
295            copy[i] = array[i];
296    }
297    return copy;
298};
299
300exports.deepCopy = function deepCopy(obj) {
301    if (typeof obj !== "object" || !obj)
302        return obj;
303    var copy;
304    if (Array.isArray(obj)) {
305        copy = [];
306        for (var key = 0; key < obj.length; key++) {
307            copy[key] = deepCopy(obj[key]);
308        }
309        return copy;
310    }
311    if (Object.prototype.toString.call(obj) !== "[object Object]")
312        return obj;
313    
314    copy = {};
315    for (var key in obj)
316        copy[key] = deepCopy(obj[key]);
317    return copy;
318};
319
320exports.arrayToMap = function(arr) {
321    var map = {};
322    for (var i=0; i<arr.length; i++) {
323        map[arr[i]] = 1;
324    }
325    return map;
326
327};
328
329exports.createMap = function(props) {
330    var map = Object.create(null);
331    for (var i in props) {
332        map[i] = props[i];
333    }
334    return map;
335};
336exports.arrayRemove = function(array, value) {
337  for (var i = 0; i <= array.length; i++) {
338    if (value === array[i]) {
339      array.splice(i, 1);
340    }
341  }
342};
343
344exports.escapeRegExp = function(str) {
345    return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
346};
347
348exports.escapeHTML = function(str) {
349    return ("" + str).replace(/&/g, "&#38;").replace(/"/g, "&#34;").replace(/'/g, "&#39;").replace(/</g, "&#60;");
350};
351
352exports.getMatchOffsets = function(string, regExp) {
353    var matches = [];
354
355    string.replace(regExp, function(str) {
356        matches.push({
357            offset: arguments[arguments.length-2],
358            length: str.length
359        });
360    });
361
362    return matches;
363};
364exports.deferredCall = function(fcn) {
365    var timer = null;
366    var callback = function() {
367        timer = null;
368        fcn();
369    };
370
371    var deferred = function(timeout) {
372        deferred.cancel();
373        timer = setTimeout(callback, timeout || 0);
374        return deferred;
375    };
376
377    deferred.schedule = deferred;
378
379    deferred.call = function() {
380        this.cancel();
381        fcn();
382        return deferred;
383    };
384
385    deferred.cancel = function() {
386        clearTimeout(timer);
387        timer = null;
388        return deferred;
389    };
390    
391    deferred.isPending = function() {
392        return timer;
393    };
394
395    return deferred;
396};
397
398
399exports.delayedCall = function(fcn, defaultTimeout) {
400    var timer = null;
401    var callback = function() {
402        timer = null;
403        fcn();
404    };
405
406    var _self = function(timeout) {
407        if (timer == null)
408            timer = setTimeout(callback, timeout || defaultTimeout);
409    };
410
411    _self.delay = function(timeout) {
412        timer && clearTimeout(timer);
413        timer = setTimeout(callback, timeout || defaultTimeout);
414    };
415    _self.schedule = _self;
416
417    _self.call = function() {
418        this.cancel();
419        fcn();
420    };
421
422    _self.cancel = function() {
423        timer && clearTimeout(timer);
424        timer = null;
425    };
426
427    _self.isPending = function() {
428        return timer;
429    };
430
431    return _self;
432};
433});
434
435define("ace/range",[], function(require, exports, module) {
436"use strict";
437var comparePoints = function(p1, p2) {
438    return p1.row - p2.row || p1.column - p2.column;
439};
440var Range = function(startRow, startColumn, endRow, endColumn) {
441    this.start = {
442        row: startRow,
443        column: startColumn
444    };
445
446    this.end = {
447        row: endRow,
448        column: endColumn
449    };
450};
451
452(function() {
453    this.isEqual = function(range) {
454        return this.start.row === range.start.row &&

455            this.end.row === range.end.row &&
456            this.start.column === range.start.column &&
457            this.end.column === range.end.column;
458    };
459    this.toString = function() {
460        return ("Range: [" + this.start.row + "/" + this.start.column +
461            "] -> [" + this.end.row + "/" + this.end.column + "]");
462    };
463
464    this.contains = function(row, column) {
465        return this.compare(row, column) == 0;
466    };
467    this.compareRange = function(range) {
468        var cmp,
469            end = range.end,
470            start = range.start;
471
472        cmp = this.compare(end.row, end.column);
473        if (cmp == 1) {
474            cmp = this.compare(start.row, start.column);
475            if (cmp == 1) {
476                return 2;
477            } else if (cmp == 0) {
478                return 1;
479            } else {
480                return 0;
481            }
482        } else if (cmp == -1) {
483            return -2;
484        } else {
485            cmp = this.compare(start.row, start.column);
486            if (cmp == -1) {
487                return -1;
488            } else if (cmp == 1) {
489                return 42;
490            } else {
491                return 0;
492            }
493        }
494    };
495    this.comparePoint = function(p) {
496        return this.compare(p.row, p.column);
497    };
498    this.containsRange = function(range) {
499        return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;
500    };
501    this.intersects = function(range) {
502        var cmp = this.compareRange(range);
503        return (cmp == -1 || cmp == 0 || cmp == 1);
504    };
505    this.isEnd = function(row, column) {
506        return this.end.row == row && this.end.column == column;
507    };
508    this.isStart = function(row, column) {
509        return this.start.row == row && this.start.column == column;
510    };
511    this.setStart = function(row, column) {
512        if (typeof row == "object") {
513            this.start.column = row.column;
514            this.start.row = row.row;
515        } else {
516            this.start.row = row;
517            this.start.column = column;
518        }
519    };
520    this.setEnd = function(row, column) {
521        if (typeof row == "object") {
522            this.end.column = row.column;
523            this.end.row = row.row;
524        } else {
525            this.end.row = row;
526            this.end.column = column;
527        }
528    };
529    this.inside = function(row, column) {
530        if (this.compare(row, column) == 0) {
531            if (this.isEnd(row, column) || this.isStart(row, column)) {
532                return false;
533            } else {
534                return true;
535            }
536        }
537        return false;
538    };
539    this.insideStart = function(row, column) {
540        if (this.compare(row, column) == 0) {
541            if (this.isEnd(row, column)) {
542                return false;
543            } else {
544                return true;
545            }
546        }
547        return false;
548    };
549    this.insideEnd = function(row, column) {
550        if (this.compare(row, column) == 0) {
551            if (this.isStart(row, column)) {
552                return false;
553            } else {
554                return true;
555            }
556        }
557        return false;
558    };
559    this.compare = function(row, column) {
560        if (!this.isMultiLine()) {
561            if (row === this.start.row) {
562                return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0);
563            }
564        }
565
566        if (row < this.start.row)
567            return -1;
568
569        if (row > this.end.row)
570            return 1;
571
572        if (this.start.row === row)
573            return column >= this.start.column ? 0 : -1;
574
575        if (this.end.row === row)
576            return column <= this.end.column ? 0 : 1;
577
578        return 0;
579    };
580    this.compareStart = function(row, column) {
581        if (this.start.row == row && this.start.column == column) {
582            return -1;
583        } else {
584            return this.compare(row, column);
585        }
586    };
587    this.compareEnd = function(row, column) {
588        if (this.end.row == row && this.end.column == column) {
589            return 1;
590        } else {
591            return this.compare(row, column);
592        }
593    };
594    this.compareInside = function(row, column) {

595        if (this.end.row == row && this.end.column == column) {
596            return 1;
597        } else if (this.start.row == row && this.start.column == column) {
598            return -1;
599        } else {
600            return this.compare(row, column);
601        }
602    };
603    this.clipRows = function(firstRow, lastRow) {
604        if (this.end.row > lastRow)
605            var end = {row: lastRow + 1, column: 0};
606        else if (this.end.row < firstRow)
607            var end = {row: firstRow, column: 0};
608
609        if (this.start.row > lastRow)
610            var start = {row: lastRow + 1, column: 0};
611        else if (this.start.row < firstRow)
612            var start = {row: firstRow, column: 0};
613
614        return Range.fromPoints(start || this.start, end || this.end);
615    };
616    this.extend = function(row, column) {
617        var cmp = this.compare(row, column);
618
619        if (cmp == 0)
620            return this;
621        else if (cmp == -1)
622            var start = {row: row, column: column};
623        else
624            var end = {row: row, column: column};
625
626        return Range.fromPoints(start || this.start, end || this.end);
627    };
628
629    this.isEmpty = function() {
630        return (this.start.row === this.end.row && this.start.column === this.end.column);
631    };
632    this.isMultiLine = function() {
633        return (this.start.row !== this.end.row);
634    };
635    this.clone = function() {
636        return Range.fromPoints(this.start, this.end);
637    };
638    this.collapseRows = function() {
639        if (this.end.column == 0)
640            return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row-1), 0);
641        else
642            return new Range(this.start.row, 0, this.end.row, 0);
643    };
644    this.toScreenRange = function(session) {
645        var screenPosStart = session.documentToScreenPosition(this.start);
646        var screenPosEnd = session.documentToScreenPosition(this.end);
647
648        return new Range(
649            screenPosStart.row, screenPosStart.column,
650            screenPosEnd.row, screenPosEnd.column
651        );
652    };
653    this.moveBy = function(row, column) {
654        this.start.row += row;
655        this.start.column += column;
656        this.end.row += row;
657        this.end.column += column;
658    };
659
660}).call(Range.prototype);
661Range.fromPoints = function(start, end) {
662    return new Range(start.row, start.column, end.row, end.column);
663};
664Range.comparePoints = comparePoints;
665
666Range.comparePoints = function(p1, p2) {
667    return p1.row - p2.row || p1.column - p2.column;
668};
669
670
671exports.Range = Range;
672});
673
674define("ace/apply_delta",[], function(require, exports, module) {
675"use strict";
676
677function throwDeltaError(delta, errorText){
678    console.log("Invalid Delta:", delta);
679    throw "Invalid Delta: " + errorText;
680}
681
682function positionInDocument(docLines, position) {
683    return position.row    >= 0 && position.row    <  docLines.length &&
684           position.column >= 0 && position.column <= docLines[position.row].length;
685}
686
687function validateDelta(docLines, delta) {
688    if (delta.action != "insert" && delta.action != "remove")
689        throwDeltaError(delta, "delta.action must be 'insert' or 'remove'");
690    if (!(delta.lines instanceof Array))
691        throwDeltaError(delta, "delta.lines must be an Array");
692    if (!delta.start || !delta.end)
693       throwDeltaError(delta, "delta.start/end must be an present");
694    var start = delta.start;
695    if (!positionInDocument(docLines, delta.start))
696        throwDeltaError(delta, "delta.start must be contained in document");
697    var end = delta.end;
698    if (delta.action == "remove" && !positionInDocument(docLines, end))
699        throwDeltaError(delta, "delta.end must contained in document for 'remove' actions");
700    var numRangeRows = end.row - start.row;
701    var numRangeLastLineChars = (end.column - (numRangeRows == 0 ? start.column : 0));
702    if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars)
703        throwDeltaError(delta, "delta.range must match delta lines");
704}
705
706exports.applyDelta = function(docLines, delta, doNotValidate) {
707    
708    var row = delta.start.row;
709    var startColumn = delta.start.column;
710    var line = docLines[row] || "";
711    switch (delta.action) {
712        case "insert":
713            var lines = delta.lines;
714            if (lines.length === 1) {
715                docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn);
716            } else {
717                var args = [row, 1].concat(delta.lines);
718                docLines.splice.apply(docLines, args);
719                docLines[row] = line.substring(0, startColumn) + docLines[row];
720                docLines[row + delta.lines.length - 1] += line.substring(startColumn);
721            }
722            break;
723        case "remove":
724            var endColumn = delta.end.column;
725            var endRow = delta.end.row;
726            if (row === endRow) {
727                docLines[row] = line.substring(0, startColumn) + line.substring(endColumn);
728            } else {
729                docLines.splice(
730                    row, endRow - row + 1,
731                    line.substring(0, startColumn) + docLines[endRow].substring(endColumn)
732                );
733            }
734            break;
735    }
736};
737});
738
739define("ace/lib/event_emitter",[], function(require, exports, module) {
740"use strict";
741
742var EventEmitter = {};

743var stopPropagation = function() { this.propagationStopped = true; };
744var preventDefault = function() { this.defaultPrevented = true; };
745
746EventEmitter._emit =
747EventEmitter._dispatchEvent = function(eventName, e) {
748    this._eventRegistry || (this._eventRegistry = {});
749    this._defaultHandlers || (this._defaultHandlers = {});
750
751    var listeners = this._eventRegistry[eventName] || [];
752    var defaultHandler = this._defaultHandlers[eventName];
753    if (!listeners.length && !defaultHandler)
754        return;
755
756    if (typeof e != "object" || !e)
757        e = {};
758
759    if (!e.type)
760        e.type = eventName;
761    if (!e.stopPropagation)
762        e.stopPropagation = stopPropagation;
763    if (!e.preventDefault)
764        e.preventDefault = preventDefault;
765
766    listeners = listeners.slice();
767    for (var i=0; i<listeners.length; i++) {
768        listeners[i](e, this);
769        if (e.propagationStopped)
770            break;
771    }
772    
773    if (defaultHandler && !e.defaultPrevented)
774        return defaultHandler(e, this);
775};
776
777
778EventEmitter._signal = function(eventName, e) {
779    var listeners = (this._eventRegistry || {})[eventName];
780    if (!listeners)
781        return;
782    listeners = listeners.slice();
783    for (var i=0; i<listeners.length; i++)
784        listeners[i](e, this);
785};
786
787EventEmitter.once = function(eventName, callback) {
788    var _self = this;
789    this.on(eventName, function newCallback() {
790        _self.off(eventName, newCallback);
791        callback.apply(null, arguments);
792    });
793    if (!callback) {
794        return new Promise(function(resolve) {
795            callback = resolve;
796        });
797    }
798};
799
800
801EventEmitter.setDefaultHandler = function(eventName, callback) {
802    var handlers = this._defaultHandlers;
803    if (!handlers)
804        handlers = this._defaultHandlers = {_disabled_: {}};
805    
806    if (handlers[eventName]) {
807        var old = handlers[eventName];
808        var disabled = handlers._disabled_[eventName];
809        if (!disabled)
810            handlers._disabled_[eventName] = disabled = [];
811        disabled.push(old);
812        var i = disabled.indexOf(callback);
813        if (i != -1) 
814            disabled.splice(i, 1);
815    }
816    handlers[eventName] = callback;
817};
818EventEmitter.removeDefaultHandler = function(eventName, callback) {
819    var handlers = this._defaultHandlers;
820    if (!handlers)
821        return;
822    var disabled = handlers._disabled_[eventName];
823    
824    if (handlers[eventName] == callback) {
825        if (disabled)
826            this.setDefaultHandler(eventName, disabled.pop());
827    } else if (disabled) {
828        var i = disabled.indexOf(callback);
829        if (i != -1)
830            disabled.splice(i, 1);
831    }
832};
833
834EventEmitter.on =
835EventEmitter.addEventListener = function(eventName, callback, capturing) {
836    this._eventRegistry = this._eventRegistry || {};
837
838    var listeners = this._eventRegistry[eventName];
839    if (!listeners)
840        listeners = this._eventRegistry[eventName] = [];
841
842    if (listeners.indexOf(callback) == -1)
843        listeners[capturing ? "unshift" : "push"](callback);
844    return callback;
845};
846
847EventEmitter.off =
848EventEmitter.removeListener =
849EventEmitter.removeEventListener = function(eventName, callback) {
850    this._eventRegistry = this._eventRegistry || {};
851
852    var listeners = this._eventRegistry[eventName];
853    if (!listeners)
854        return;
855
856    var index = listeners.indexOf(callback);
857    if (index !== -1)
858        listeners.splice(index, 1);
859};
860
861EventEmitter.removeAllListeners = function(eventName) {
862    if (!eventName) this._eventRegistry = this._defaultHandlers = undefined;
863    if (this._eventRegistry) this._eventRegistry[eventName] = undefined;
864    if (this._defaultHandlers) this._defaultHandlers[eventName] = undefined;
865};
866
867exports.EventEmitter = EventEmitter;
868
869});
870
871define("ace/anchor",[], function(require, exports, module) {
872"use strict";
873
874var oop = require("./lib/oop");
875var EventEmitter = require("./lib/event_emitter").EventEmitter;
876
877var Anchor = exports.Anchor = function(doc, row, column) {
878    this.$onChange = this.onChange.bind(this);
879    this.attach(doc);
880    
881    if (typeof column == "undefined")
882        this.setPosition(row.row, row.column);
883    else
884        this.setPosition(row, column);
885};
886
887(function() {
888
889    oop.implement(this, EventEmitter);
890    this.getPosition = function() {
891        return this.$clipPositionToDocument(this.row, this.column);
892    };
893    this.getDocument = function() {
894        return this.document;
895    };
896    this.$insertRight = false;

897    this.onChange = function(delta) {
898        if (delta.start.row == delta.end.row && delta.start.row != this.row)
899            return;
900
901        if (delta.start.row > this.row)
902            return;
903            
904        var point = $getTransformedPoint(delta, {row: this.row, column: this.column}, this.$insertRight);
905        this.setPosition(point.row, point.column, true);
906    };
907    
908    function $pointsInOrder(point1, point2, equalPointsInOrder) {
909        var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column;
910        return (point1.row < point2.row) || (point1.row == point2.row && bColIsAfter);
911    }
912            
913    function $getTransformedPoint(delta, point, moveIfEqual) {
914        var deltaIsInsert = delta.action == "insert";
915        var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row    - delta.start.row);
916        var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column);
917        var deltaStart = delta.start;
918        var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range.
919        if ($pointsInOrder(point, deltaStart, moveIfEqual)) {
920            return {
921                row: point.row,
922                column: point.column
923            };
924        }
925        if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) {
926            return {
927                row: point.row + deltaRowShift,
928                column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0)
929            };
930        }
931        
932        return {
933            row: deltaStart.row,
934            column: deltaStart.column
935        };
936    }
937    this.setPosition = function(row, column, noClip) {
938        var pos;
939        if (noClip) {
940            pos = {
941                row: row,
942                column: column
943            };
944        } else {
945            pos = this.$clipPositionToDocument(row, column);
946        }
947
948        if (this.row == pos.row && this.column == pos.column)
949            return;
950
951        var old = {
952            row: this.row,
953            column: this.column
954        };
955
956        this.row = pos.row;
957        this.column = pos.column;
958        this._signal("change", {
959            old: old,
960            value: pos
961        });
962    };
963    this.detach = function() {
964        this.document.off("change", this.$onChange);
965    };
966    this.attach = function(doc) {
967        this.document = doc || this.document;
968        this.document.on("change", this.$onChange);
969    };
970    this.$clipPositionToDocument = function(row, column) {
971        var pos = {};
972
973        if (row >= this.document.getLength()) {
974            pos.row = Math.max(0, this.document.getLength() - 1);
975            pos.column = this.document.getLine(pos.row).length;
976        }
977        else if (row < 0) {
978            pos.row = 0;
979            pos.column = 0;
980        }
981        else {
982            pos.row = row;
983            pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));
984        }
985
986        if (column < 0)
987            pos.column = 0;
988
989        return pos;
990    };
991
992}).call(Anchor.prototype);
993
994});
995
996define("ace/document",[], function(require, exports, module) {
997"use strict";
998
999var oop = require("./lib/oop");
1000var applyDelta = require("./apply_delta").applyDelta;
1001var EventEmitter = require("./lib/event_emitter").EventEmitter;
1002var Range = require("./range").Range;
1003var Anchor = require("./anchor").Anchor;
1004
1005var Document = function(textOrLines) {
1006    this.$lines = [""];
1007    if (textOrLines.length === 0) {
1008        this.$lines = [""];
1009    } else if (Array.isArray(textOrLines)) {
1010        this.insertMergedLines({row: 0, column: 0}, textOrLines);
1011    } else {
1012        this.insert({row: 0, column:0}, textOrLines);
1013    }
1014};
1015
1016(function() {
1017
1018    oop.implement(this, EventEmitter);
1019    this.setValue = function(text) {
1020        var len = this.getLength() - 1;
1021        this.remove(new Range(0, 0, len, this.getLine(len).length));
1022        this.insert({row: 0, column: 0}, text);
1023    };
1024    this.getValue = function() {
1025        return this.getAllLines().join(this.getNewLineCharacter());
1026    };
1027    this.createAnchor = function(row, column) {

1028        return new Anchor(this, row, column);
1029    };
1030    if ("aaa".split(/a/).length === 0) {
1031        this.$split = function(text) {
1032            return text.replace(/\r\n|\r/g, "\n").split("\n");
1033        };
1034    } else {
1035        this.$split = function(text) {
1036            return text.split(/\r\n|\r|\n/);
1037        };
1038    }
1039
1040
1041    this.$detectNewLine = function(text) {
1042        var match = text.match(/^.*?(\r\n|\r|\n)/m);
1043        this.$autoNewLine = match ? match[1] : "\n";
1044        this._signal("changeNewLineMode");
1045    };
1046    this.getNewLineCharacter = function() {
1047        switch (this.$newLineMode) {
1048          case "windows":
1049            return "\r\n";
1050          case "unix":
1051            return "\n";
1052          default:
1053            return this.$autoNewLine || "\n";
1054        }
1055    };
1056
1057    this.$autoNewLine = "";
1058    this.$newLineMode = "auto";
1059    this.setNewLineMode = function(newLineMode) {
1060        if (this.$newLineMode === newLineMode)
1061            return;
1062
1063        this.$newLineMode = newLineMode;
1064        this._signal("changeNewLineMode");
1065    };
1066    this.getNewLineMode = function() {
1067        return this.$newLineMode;
1068    };
1069    this.isNewLine = function(text) {
1070        return (text == "\r\n" || text == "\r" || text == "\n");
1071    };
1072    this.getLine = function(row) {
1073        return this.$lines[row] || "";
1074    };
1075    this.getLines = function(firstRow, lastRow) {
1076        return this.$lines.slice(firstRow, lastRow + 1);
1077    };
1078    this.getAllLines = function() {
1079        return this.getLines(0, this.getLength());
1080    };
1081    this.getLength = function() {
1082        return this.$lines.length;
1083    };
1084    this.getTextRange = function(range) {
1085        return this.getLinesForRange(range).join(this.getNewLineCharacter());
1086    };
1087    this.getLinesForRange = function(range) {
1088        var lines;
1089        if (range.start.row === range.end.row) {
1090            lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)];
1091        } else {
1092            lines = this.getLines(range.start.row, range.end.row);
1093            lines[0] = (lines[0] || "").substring(range.start.column);
1094            var l = lines.length - 1;
1095            if (range.end.row - range.start.row == l)
1096                lines[l] = lines[l].substring(0, range.end.column);
1097        }
1098        return lines;
1099    };
1100    this.insertLines = function(row, lines) {
1101        console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead.");
1102        return this.insertFullLines(row, lines);
1103    };
1104    this.removeLines = function(firstRow, lastRow) {
1105        console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead.");
1106        return this.removeFullLines(firstRow, lastRow);
1107    };
1108    this.insertNewLine = function(position) {
1109        console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead.");
1110        return this.insertMergedLines(position, ["", ""]);
1111    };
1112    this.insert = function(position, text) {
1113        if (this.getLength() <= 1)
1114            this.$detectNewLine(text);
1115        
1116        return this.insertMergedLines(position, this.$split(text));
1117    };
1118    this.insertInLine = function(position, text) {
1119        var start = this.clippedPos(position.row, position.column);
1120        var end = this.pos(position.row, position.column + text.length);
1121        
1122        this.applyDelta({
1123            start: start,
1124            end: end,
1125            action: "insert",
1126            lines: [text]
1127        }, true);
1128        
1129        return this.clonePos(end);
1130    };
1131    
1132    this.clippedPos = function(row, column) {
1133        var length = this.getLength();
1134        if (row === undefined) {
1135            row = length;
1136        } else if (row < 0) {
1137            row = 0;
1138        } else if (row >= length) {
1139            row = length - 1;
1140            column = undefined;
1141        }
1142        var line = this.getLine(row);
1143        if (column == undefined)
1144            column = line.length;
1145        column = Math.min(Math.max(column, 0), line.length);
1146        return {row: row, column: column};
1147    };
1148    
1149    this.clonePos = function(pos) {
1150        return {row: pos.row, column: pos.column};
1151    };
1152    
1153    this.pos = function(row, column) {
1154        return {row: row, column: column};
1155    };
1156    
1157    this.$clipPosition = function(position) {
1158        var length = this.getLength();
1159        if (position.row >= length) {
1160            position.row = Math.max(0, length - 1);
1161            position.column = this.getLine(length - 1).length;
1162        } else {
1163            position.row = Math.max(0, position.row);
1164            position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length);
1165        }
1166        return position;
1167    };
1168    this.insertFullLines = function(row, lines) {
1169        row = Math.min(Math.max(row, 0), this.getLength());
1170        var column = 0;
1171        if (row < this.getLength()) {
1172            lines = lines.concat([""]);
1173            column = 0;
1174        } else {
1175            lines = [""].concat(lines);
1176            row--;
1177            column = this.$lines[row].length;
1178        }
1179        this.insertMergedLines({row: row, column: column}, lines);
1180    };    
1181    this.insertMergedLines = function(position, lines) {
1182        var start = this.clippedPos(position.row, position.column);
1183        var end = {
1184            row: start.row + lines.length - 1,
1185            column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length
1186        };
1187        
1188        this.applyDelta({
1189            start: start,
1190            end: end,
1191            action: "insert",
1192            lines: lines
1193        });
1194        
1195        return this.clonePos(end);
1196    };
1197    this.remove = function(range) {
1198        var start = this.clippedPos(range.start.row, range.start.column);
1199        var end = this.clippedPos(range.end.row, range.end.column);
1200        this.applyDelta({
1201            start: start,
1202            end: end,
1203            action: "remove",
1204            lines: this.getLinesForRange({start: start, end: end})
1205        });
1206        return this.clonePos(start);
1207    };
1208    this.removeInLine = function(row, startColumn, endColumn) {
1209        var start = this.clippedPos(row, startColumn);
1210        var end = this.clippedPos(row, endColumn);
1211        
1212        this.applyDelta({
1213            start: start,
1214            end: end,
1215            action: "remove",
1216            lines: this.getLinesForRange({start: start, end: end})
1217        }, true);
1218        
1219        return this.clonePos(start);
1220    };
1221    this.removeFullLines = function(firstRow, lastRow) {
1222        firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1);
1223        lastRow  = Math.min(Math.max(0, lastRow ), this.getLength() - 1);
1224        var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0;
1225        var deleteLastNewLine  = lastRow  < this.getLength() - 1;
1226        var startRow = ( deleteFirstNewLine ? firstRow - 1                  : firstRow                    );
1227        var startCol = ( deleteFirstNewLine ? this.getLine(startRow).length : 0                           );
1228        var endRow   = ( deleteLastNewLine  ? lastRow + 1                   : lastRow                     );
1229        var endCol   = ( deleteLastNewLine  ? 0                             : this.getLine(endRow).length ); 
1230        var range = new Range(startRow, startCol, endRow, endCol);

1231        var deletedLines = this.$lines.slice(firstRow, lastRow + 1);
1232        
1233        this.applyDelta({
1234            start: range.start,
1235            end: range.end,
1236            action: "remove",
1237            lines: this.getLinesForRange(range)
1238        });
1239        return deletedLines;
1240    };
1241    this.removeNewLine = function(row) {
1242        if (row < this.getLength() - 1 && row >= 0) {
1243            this.applyDelta({
1244                start: this.pos(row, this.getLine(row).length),
1245                end: this.pos(row + 1, 0),
1246                action: "remove",
1247                lines: ["", ""]
1248            });
1249        }
1250    };
1251    this.replace = function(range, text) {
1252        if (!(range instanceof Range))
1253            range = Range.fromPoints(range.start, range.end);
1254        if (text.length === 0 && range.isEmpty())
1255            return range.start;
1256        if (text == this.getTextRange(range))
1257            return range.end;
1258
1259        this.remove(range);
1260        var end;
1261        if (text) {
1262            end = this.insert(range.start, text);
1263        }
1264        else {
1265            end = range.start;
1266        }
1267        
1268        return end;
1269    };
1270    this.applyDeltas = function(deltas) {
1271        for (var i=0; i<deltas.length; i++) {
1272            this.applyDelta(deltas[i]);
1273        }
1274    };
1275    this.revertDeltas = function(deltas) {
1276        for (var i=deltas.length-1; i>=0; i--) {
1277            this.revertDelta(deltas[i]);
1278        }
1279    };
1280    this.applyDelta = function(delta, doNotValidate) {
1281        var isInsert = delta.action == "insert";
1282        if (isInsert ? delta.lines.length <= 1 && !delta.lines[0]
1283            : !Range.comparePoints(delta.start, delta.end)) {
1284            return;
1285        }
1286        
1287        if (isInsert && delta.lines.length > 20000) {
1288            this.$splitAndapplyLargeDelta(delta, 20000);
1289        }
1290        else {
1291            applyDelta(this.$lines, delta, doNotValidate);
1292            this._signal("change", delta);
1293        }
1294    };
1295    
1296    this.$safeApplyDelta = function(delta) {
1297        var docLength = this.$lines.length;
1298        if (
1299            delta.action == "remove" && delta.start.row < docLength && delta.end.row < docLength
1300            || delta.action == "insert" && delta.start.row <= docLength
1301        ) {
1302            this.applyDelta(delta);
1303        }
1304    };
1305    
1306    this.$splitAndapplyLargeDelta = function(delta, MAX) {
1307        var lines = delta.lines;
1308        var l = lines.length - MAX + 1;
1309        var row = delta.start.row; 
1310        var column = delta.start.column;
1311        for (var from = 0, to = 0; from < l; from = to) {
1312            to += MAX - 1;
1313            var chunk = lines.slice(from, to);
1314            chunk.push("");
1315            this.applyDelta({
1316                start: this.pos(row + from, column),
1317                end: this.pos(row + to, column = 0),
1318                action: delta.action,
1319                lines: chunk
1320            }, true);
1321        }
1322        delta.lines = lines.slice(from);
1323        delta.start.row = row + from;
1324        delta.start.column = column;
1325        this.applyDelta(delta, true);
1326    };
1327    this.revertDelta = function(delta) {
1328        this.$safeApplyDelta({
1329            start: this.clonePos(delta.start),
1330            end: this.clonePos(delta.end),
1331            action: (delta.action == "insert" ? "remove" : "insert"),
1332            lines: delta.lines.slice()
1333        });
1334    };
1335    this.indexToPosition = function(index, startRow) {
1336        var lines = this.$lines || this.getAllLines();
1337        var newlineLength = this.getNewLineCharacter().length;
1338        for (var i = startRow || 0, l = lines.length; i < l; i++) {
1339            index -= lines[i].length + newlineLength;
1340            if (index < 0)
1341                return {row: i, column: index + lines[i].length + newlineLength};
1342        }
1343        return {row: l-1, column: index + lines[l-1].length + newlineLength};
1344    };
1345    this.positionToIndex = function(pos, startRow) {
1346        var lines = this.$lines || this.getAllLines();
1347        var newlineLength = this.getNewLineCharacter().length;
1348        var index = 0;
1349        var row = Math.min(pos.row, lines.length);
1350        for (var i = startRow || 0; i < row; ++i)
1351            index += lines[i].length + newlineLength;
1352
1353        return index + pos.column;
1354    };
1355
1356}).call(Document.prototype);
1357
1358exports.Document = Document;
1359});
1360
1361define("ace/worker/mirror",[], function(require, exports, module) {
1362"use strict";
1363
1364var Range = require("../range").Range;
1365var Document = require("../document").Document;
1366var lang = require("../lib/lang");
1367    
1368var Mirror = exports.Mirror = function(sender) {
1369    this.sender = sender;
1370    var doc = this.doc = new Document("");
1371    
1372    var deferredUpdate = this.deferredUpdate = lang.delayedCall(this.onUpdate.bind(this));
1373    
1374    var _self = this;
1375    sender.on("change", function(e) {
1376        var data = e.data;
1377        if (data[0].start) {
1378            doc.applyDeltas(data);
1379        } else {
1380            for (var i = 0; i < data.length; i += 2) {

1381                if (Array.isArray(data[i+1])) {
1382                    var d = {action: "insert", start: data[i], lines: data[i+1]};
1383                } else {
1384                    var d = {action: "remove", start: data[i], end: data[i+1]};
1385                }
1386                doc.applyDelta(d, true);
1387            }
1388        }
1389        if (_self.$timeout)
1390            return deferredUpdate.schedule(_self.$timeout);
1391        _self.onUpdate();
1392    });
1393};
1394
1395(function() {
1396    
1397    this.$timeout = 500;
1398    
1399    this.setTimeout = function(timeout) {
1400        this.$timeout = timeout;
1401    };
1402    
1403    this.setValue = function(value) {
1404        this.doc.setValue(value);
1405        this.deferredUpdate.schedule(this.$timeout);
1406    };
1407    
1408    this.getValue = function(callbackId) {
1409        this.sender.callback(this.doc.getValue(), callbackId);
1410    };
1411    
1412    this.onUpdate = function() {
1413    };
1414    
1415    this.isPending = function() {
1416        return this.deferredUpdate.isPending();
1417    };
1418    
1419}).call(Mirror.prototype);
1420
1421});
1422
1423define("ace/mode/html/saxparser",[], function(require, exports, module) {
1424module.exports = (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({
14251:[function(_dereq_,module,exports){
1426function isScopeMarker(node) {
1427	if (node.namespaceURI === "http://www.w3.org/1999/xhtml") {
1428		return node.localName === "applet"
1429			|| node.localName === "caption"
1430			|| node.localName === "marquee"
1431			|| node.localName === "object"
1432			|| node.localName === "table"
1433			|| node.localName === "td"
1434			|| node.localName === "th";
1435	}
1436	if (node.namespaceURI === "http://www.w3.org/1998/Math/MathML") {
1437		return node.localName === "mi"
1438			|| node.localName === "mo"
1439			|| node.localName === "mn"
1440			|| node.localName === "ms"
1441			|| node.localName === "mtext"
1442			|| node.localName === "annotation-xml";
1443	}
1444	if (node.namespaceURI === "http://www.w3.org/2000/svg") {
1445		return node.localName === "foreignObject"
1446			|| node.localName === "desc"
1447			|| node.localName === "title";
1448	}
1449}
1450
1451function isListItemScopeMarker(node) {
1452	return isScopeMarker(node)
1453		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'ol')
1454		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'ul');
1455}
1456
1457function isTableScopeMarker(node) {
1458	return (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'table')
1459		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'html');
1460}
1461
1462function isTableBodyScopeMarker(node) {
1463	return (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'tbody')
1464		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'tfoot')
1465		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'thead')
1466		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'html');
1467}
1468
1469function isTableRowScopeMarker(node) {
1470	return (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'tr')
1471		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'html');
1472}
1473
1474function isButtonScopeMarker(node) {
1475	return isScopeMarker(node)
1476		|| (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'button');
1477}
1478
1479function isSelectScopeMarker(node) {
1480	return !(node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'optgroup')
1481		&& !(node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'option');
1482}
1483function ElementStack() {
1484	this.elements = [];
1485	this.rootNode = null;
1486	this.headElement = null;
1487	this.bodyElement = null;
1488}
1489ElementStack.prototype._inScope = function(localName, isMarker) {
1490	for (var i = this.elements.length - 1; i >= 0; i--) {
1491		var node = this.elements[i];
1492		if (node.localName === localName)
1493			return true;
1494		if (isMarker(node))
1495			return false;

1496	}
1497};
1498ElementStack.prototype.push = function(item) {
1499	this.elements.push(item);
1500};
1501ElementStack.prototype.pushHtmlElement = function(item) {
1502	this.rootNode = item.node;
1503	this.push(item);
1504};
1505ElementStack.prototype.pushHeadElement = function(item) {
1506	this.headElement = item.node;
1507	this.push(item);
1508};
1509ElementStack.prototype.pushBodyElement = function(item) {
1510	this.bodyElement = item.node;
1511	this.push(item);
1512};
1513ElementStack.prototype.pop = function() {
1514	return this.elements.pop();
1515};
1516ElementStack.prototype.remove = function(item) {
1517	this.elements.splice(this.elements.indexOf(item), 1);
1518};
1519ElementStack.prototype.popUntilPopped = function(localName) {
1520	var element;
1521	do {
1522		element = this.pop();
1523	} while (element.localName != localName);
1524};
1525
1526ElementStack.prototype.popUntilTableScopeMarker = function() {
1527	while (!isTableScopeMarker(this.top))
1528		this.pop();
1529};
1530
1531ElementStack.prototype.popUntilTableBodyScopeMarker = function() {
1532	while (!isTableBodyScopeMarker(this.top))
1533		this.pop();
1534};
1535
1536ElementStack.prototype.popUntilTableRowScopeMarker = function() {
1537	while (!isTableRowScopeMarker(this.top))
1538		this.pop();
1539};
1540ElementStack.prototype.item = function(index) {
1541	return this.elements[index];
1542};
1543ElementStack.prototype.contains = function(element) {
1544	return this.elements.indexOf(element) !== -1;
1545};
1546ElementStack.prototype.inScope = function(localName) {
1547	return this._inScope(localName, isScopeMarker);
1548};
1549ElementStack.prototype.inListItemScope = function(localName) {
1550	return this._inScope(localName, isListItemScopeMarker);
1551};
1552ElementStack.prototype.inTableScope = function(localName) {
1553	return this._inScope(localName, isTableScopeMarker);
1554};
1555ElementStack.prototype.inButtonScope = function(localName) {
1556	return this._inScope(localName, isButtonScopeMarker);
1557};
1558ElementStack.prototype.inSelectScope = function(localName) {
1559	return this._inScope(localName, isSelectScopeMarker);
1560};
1561ElementStack.prototype.hasNumberedHeaderElementInScope = function() {
1562	for (var i = this.elements.length - 1; i >= 0; i--) {
1563		var node = this.elements[i];
1564		if (node.isNumberedHeader())
1565			return true;
1566		if (isScopeMarker(node))
1567			return false;
1568	}
1569};
1570ElementStack.prototype.furthestBlockForFormattingElement = function(element) {
1571	var furthestBlock = null;
1572	for (var i = this.elements.length - 1; i >= 0; i--) {
1573		var node = this.elements[i];
1574		if (node.node === element)
1575			break;
1576		if (node.isSpecial())
1577			furthestBlock = node;
1578	}
1579    return furthestBlock;
1580};
1581ElementStack.prototype.findIndex = function(localName) {
1582	for (var i = this.elements.length - 1; i >= 0; i--) {
1583		if (this.elements[i].localName == localName)
1584			return i;
1585	}
1586    return -1;
1587};
1588
1589ElementStack.prototype.remove_openElements_until = function(callback) {
1590	var finished = false;
1591	var element;
1592	while (!finished) {
1593		element = this.elements.pop();
1594		finished = callback(element);
1595	}
1596	return element;
1597};
1598
1599Object.defineProperty(ElementStack.prototype, 'top', {
1600	get: function() {
1601		return this.elements[this.elements.length - 1];
1602	}
1603});
1604
1605Object.defineProperty(ElementStack.prototype, 'length', {
1606	get: function() {
1607		return this.elements.length;
1608	}
1609});
1610
1611exports.ElementStack = ElementStack;
1612
1613},
1614{}],
16152:[function(_dereq_,module,exports){
1616var entities  = _dereq_('html5-entities');
1617var InputStream = _dereq_('./InputStream').InputStream;
1618
1619var namedEntityPrefixes = {};
1620Object.keys(entities).forEach(function (entityKey) {
1621	for (var i = 0; i < entityKey.length; i++) {
1622		namedEntityPrefixes[entityKey.substring(0, i + 1)] = true;
1623	}
1624});
1625
1626function isAlphaNumeric(c) {
1627	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
1628}
1629
1630function isHexDigit(c) {
1631	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
1632}
1633
1634function isDecimalDigit(c) {
1635	return (c >= '0' && c <= '9');
1636}
1637
1638var EntityParser = {};
1639
1640EntityParser.consumeEntity = function(buffer, tokenizer, additionalAllowedCharacter) {
1641	var decodedCharacter = '';
1642	var consumedCharacters = '';
1643	var ch = buffer.char();
1644	if (ch === InputStream.EOF)
1645		return false;
1646	consumedCharacters += ch;
1647	if (ch == '\t' || ch == '\n' || ch == '\v' || ch == ' ' || ch == '<' || ch == '&') {
1648		buffer.unget(consumedCharacters);
1649		return false;

1650	}
1651	if (additionalAllowedCharacter === ch) {
1652		buffer.unget(consumedCharacters);
1653		return false;
1654	}
1655	if (ch == '#') {
1656		ch = buffer.shift(1);
1657		if (ch === InputStream.EOF) {
1658			tokenizer._parseError("expected-numeric-entity-but-got-eof");
1659			buffer.unget(consumedCharacters);
1660			return false;
1661		}
1662		consumedCharacters += ch;
1663		var radix = 10;
1664		var isDigit = isDecimalDigit;
1665		if (ch == 'x' || ch == 'X') {
1666			radix = 16;
1667			isDigit = isHexDigit;
1668			ch = buffer.shift(1);
1669			if (ch === InputStream.EOF) {
1670				tokenizer._parseError("expected-numeric-entity-but-got-eof");
1671				buffer.unget(consumedCharacters);
1672				return false;
1673			}
1674			consumedCharacters += ch;
1675		}
1676		if (isDigit(ch)) {
1677			var code = '';
1678			while (ch !== InputStream.EOF && isDigit(ch)) {
1679				code += ch;
1680				ch = buffer.char();
1681			}
1682			code = parseInt(code, radix);
1683			var replacement = this.replaceEntityNumbers(code);
1684			if (replacement) {
1685				tokenizer._parseError("invalid-numeric-entity-replaced");
1686				code = replacement;
1687			}
1688			if (code > 0xFFFF && code <= 0x10FFFF) {
1689		        code -= 0x10000;
1690		        var first = ((0xffc00 & code) >> 10) + 0xD800;
1691		        var second = (0x3ff & code) + 0xDC00;
1692				decodedCharacter = String.fromCharCode(first, second);
1693			} else
1694				decodedCharacter = String.fromCharCode(code);
1695			if (ch !== ';') {
1696				tokenizer._parseError("numeric-entity-without-semicolon");
1697				buffer.unget(ch);
1698			}
1699			return decodedCharacter;
1700		}
1701		buffer.unget(consumedCharacters);
1702		tokenizer._parseError("expected-numeric-entity");
1703		return false;
1704	}
1705	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
1706		var mostRecentMatch = '';
1707		while (namedEntityPrefixes[consumedCharacters]) {
1708			if (entities[consumedCharacters]) {
1709				mostRecentMatch = consumedCharacters;
1710			}
1711			if (ch == ';')
1712				break;
1713			ch = buffer.char();
1714			if (ch === InputStream.EOF)
1715				break;
1716			consumedCharacters += ch;
1717		}
1718		if (!mostRecentMatch) {
1719			tokenizer._parseError("expected-named-entity");
1720			buffer.unget(consumedCharacters);
1721			return false;
1722		}
1723		decodedCharacter = entities[mostRecentMatch];
1724		if (ch === ';' || !additionalAllowedCharacter || !(isAlphaNumeric(ch) || ch === '=')) {
1725			if (consumedCharacters.length > mostRecentMatch.length) {
1726				buffer.unget(consumedCharacters.substring(mostRecentMatch.length));
1727			}
1728			if (ch !== ';') {
1729				tokenizer._parseError("named-entity-without-semicolon");
1730			}
1731			return decodedCharacter;
1732		}
1733		buffer.unget(consumedCharacters);
1734		return false;
1735	}
1736};
1737
1738EntityParser.replaceEntityNumbers = function(c) {
1739	switch(c) {
1740		case 0x00: return 0xFFFD; // REPLACEMENT CHARACTER
1741		case 0x13: return 0x0010; // Carriage return
1742		case 0x80: return 0x20AC; // EURO SIGN
1743		case 0x81: return 0x0081; // <control>
1744		case 0x82: return 0x201A; // SINGLE LOW-9 QUOTATION MARK
1745		case 0x83: return 0x0192; // LATIN SMALL LETTER F WITH HOOK
1746		case 0x84: return 0x201E; // DOUBLE LOW-9 QUOTATION MARK
1747		case 0x85: return 0x2026; // HORIZONTAL ELLIPSIS
1748		case 0x86: return 0x2020; // DAGGER
1749		case 0x87: return 0x2021; // DOUBLE DAGGER
1750		case 0x88: return 0x02C6; // MODIFIER LETTER CIRCUMFLEX ACCENT
1751		case 0x89: return 0x2030; // PER MILLE SIGN
1752		case 0x8A: return 0x0160; // LATIN CAPITAL LETTER S WITH CARON
1753		case 0x8B: return 0x2039; // SINGLE LEFT-POINTING ANGLE QUOTATION MARK
1754		case 0x8C: return 0x0152; // LATIN CAPITAL LIGATURE OE
1755		case 0x8D: return 0x008D; // <control>
1756		case 0x8E: return 0x017D; // LATIN CAPITAL LETTER Z WITH CARON
1757		case 0x8F: return 0x008F; // <control>
1758		case 0x90: return 0x0090; // <control>
1759		case 0x91: return 0x2018; // LEFT SINGLE QUOTATION MARK
1760		case 0x92: return 0x2019; // RIGHT SINGLE QUOTATION MARK
1761		case 0x93: return 0x201C; // LEFT DOUBLE QUOTATION MARK
1762		case 0x94: return 0x201D; // RIGHT DOUBLE QUOTATION MARK
1763		case 0x95: return 0x2022; // BULLET
1764		case 0x96: return 0x2013; // EN DASH
1765		case 0x97: return 0x2014; // EM DASH
1766		case 0x98: return 0x02DC; // SMALL TILDE
1767		case 0x99: return 0x2122; // TRADE MARK SIGN
1768		case 0x9A: return 0x0161; // LATIN SMALL LETTER S WITH CARON
1769		case 0x9B: return 0x203A; // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
1770		case 0x9C: return 0x0153; // LATIN SMALL LIGATURE OE
1771		case 0x9D: return 0x009D; // <control>
1772		case 0x9E: return 0x017E; // LATIN SMALL LETTER Z WITH CARON
1773		case 0x9F: return 0x0178; // LATIN CAPITAL LETTER Y WITH DIAERESIS
1774		default:
1775			if ((c >= 0xD800 && c <= 0xDFFF) || c > 0x10FFFF) {
1776				return 0xFFFD;
1777			} else if ((c >= 0x0001 && c <= 0x0008) || (c >= 0x000E && c <= 0x001F) ||
1778				(c >= 0x007F && c <= 0x009F) || (c >= 0xFDD0 && c <= 0xFDEF) ||
1779				c == 0x000B || c == 0xFFFE || c == 0x1FFFE || c == 0x2FFFFE ||
1780				c == 0x2FFFF || c == 0x3FFFE || c == 0x3FFFF || c == 0x4FFFE ||
1781				c == 0x4FFFF || c == 0x5FFFE || c == 0x5FFFF || c == 0x6FFFE ||
1782				c == 0x6FFFF || c == 0x7FFFE || c == 0x7FFFF || c == 0x8FFFE ||
1783				c == 0x8FFFF || c == 0x9FFFE || c == 0x9FFFF || c == 0xAFFFE ||
1784				c == 0xAFFFF || c == 0xBFFFE || c == 0xBFFFF || c == 0xCFFFE ||
1785				c == 0xCFFFF || c == 0xDFFFE || c == 0xDFFFF || c == 0xEFFFE ||
1786				c == 0xEFFFF || c == 0xFFFFE || c == 0xFFFFF || c == 0x10FFFE ||
1787				c == 0x10FFFF) {
1788				return c;
1789			}
1790	}
1791};
1792
1793exports.EntityParser = EntityParser;
1794
1795},
1796{"./InputStream":3,"html5-entities":12}],
17973:[function(_dereq_,module,exports){
1798function InputStream() {
1799	this.data = '';
1800	this.start = 0;
1801	this.committed = 0;
1802	this.eof = false;

1803	this.lastLocation = {line: 0, column: 0};
1804}
1805
1806InputStream.EOF = -1;
1807
1808InputStream.DRAIN = -2;
1809
1810InputStream.prototype = {
1811	slice: function() {
1812		if(this.start >= this.data.length) {
1813			if(!this.eof) throw InputStream.DRAIN;
1814			return InputStream.EOF;
1815		}
1816		return this.data.slice(this.start, this.data.length);
1817	},
1818	char: function() {
1819		if(!this.eof && this.start >= this.data.length - 1) throw InputStream.DRAIN;
1820		if(this.start >= this.data.length) {
1821			return InputStream.EOF;
1822		}
1823		var ch = this.data[this.start++];
1824		if (ch === '\r')
1825			ch = '\n';
1826		return ch;
1827	},
1828	advance: function(amount) {
1829		this.start += amount;
1830		if(this.start >= this.data.length) {
1831			if(!this.eof) throw InputStream.DRAIN;
1832			return InputStream.EOF;
1833		} else {
1834			if(this.committed > this.data.length / 2) {
1835				this.lastLocation = this.location();
1836				this.data = this.data.slice(this.committed);
1837				this.start = this.start - this.committed;
1838				this.committed = 0;
1839			}
1840		}
1841	},
1842	matchWhile: function(re) {
1843		if(this.eof && this.start >= this.data.length ) return '';
1844		var r = new RegExp("^"+re+"+");
1845		var m = r.exec(this.slice());
1846		if(m) {
1847			if(!this.eof && m[0].length == this.data.length - this.start) throw InputStream.DRAIN;
1848			this.advance(m[0].length);
1849			return m[0];
1850		} else {
1851			return '';
1852		}
1853	},
1854	matchUntil: function(re) {
1855		var m, s;
1856		s = this.slice();
1857		if(s === InputStream.EOF) {
1858			return '';
1859		} else if(m = new RegExp(re + (this.eof ? "|$" : "")).exec(s)) {
1860			var t = this.data.slice(this.start, this.start + m.index);
1861			this.advance(m.index);
1862			return t.replace(/\r/g, '\n').replace(/\n{2,}/g, '\n');
1863		} else {
1864			throw InputStream.DRAIN;
1865		}
1866	},
1867	append: function(data) {
1868		this.data += data;
1869	},
1870	shift: function(n) {
1871		if(!this.eof && this.start + n >= this.data.length) throw InputStream.DRAIN;
1872		if(this.eof && this.start >= this.data.length) return InputStream.EOF;
1873		var d = this.data.slice(this.start, this.start + n).toString();
1874		this.advance(Math.min(n, this.data.length - this.start));
1875		return d;
1876	},
1877	peek: function(n) {
1878		if(!this.eof && this.start + n >= this.data.length) throw InputStream.DRAIN;
1879		if(this.eof && this.start >= this.data.length) return InputStream.EOF;
1880		return this.data.slice(this.start, Math.min(this.start + n, this.data.length)).toString();
1881	},
1882	length: function() {
1883		return this.data.length - this.start - 1;
1884	},
1885	unget: function(d) {
1886		if(d === InputStream.EOF) return;
1887		this.start -= (d.length);
1888	},
1889	undo: function() {
1890		this.start = this.committed;
1891	},
1892	commit: function() {
1893		this.committed = this.start;
1894	},
1895	location: function() {
1896		var lastLine = this.lastLocation.line;
1897		var lastColumn = this.lastLocation.column;
1898		var read = this.data.slice(0, this.committed);
1899		var newlines = read.match(/\n/g);
1900		var line = newlines ? lastLine + newlines.length : lastLine;
1901		var column = newlines ? read.length - read.lastIndexOf('\n') - 1 : lastColumn + read.length;
1902		return {line: line, column: column};
1903	}
1904};
1905
1906exports.InputStream = InputStream;
1907
1908},
1909{}],
19104:[function(_dereq_,module,exports){
1911var SpecialElements = {
1912	"http://www.w3.org/1999/xhtml": [
1913		'address',
1914		'applet',
1915		'area',
1916		'article',
1917		'aside',
1918		'base',
1919		'basefont',
1920		'bgsound',
1921		'blockquote',
1922		'body',
1923		'br',
1924		'button',
1925		'caption',
1926		'center',
1927		'col',
1928		'colgroup',
1929		'dd',
1930		'details',
1931		'dir',
1932		'div',
1933		'dl',
1934		'dt',
1935		'embed',
1936		'fieldset',
1937		'figcaption',
1938		'figure',
1939		'footer',
1940		'form',
1941		'frame',
1942		'frameset',
1943		'h1',
1944		'h2',
1945		'h3',
1946		'h4',
1947		'h5',
1948		'h6',
1949		'head',
1950		'header',
1951		'hgroup',
1952		'hr',
1953		'html',
1954		'iframe',
1955		'img',
1956		'input',
1957		'isindex',
1958		'li',
1959		'link',
1960		'listing',
1961		'main',
1962		'marquee',
1963		'menu',
1964		'menuitem',
1965		'meta',
1966		'nav',
1967		'noembed',
1968		'noframes',
1969		'noscript',
1970		'object',
1971		'ol',
1972		'p',
1973		'param',
1974		'plaintext',
1975		'pre',
1976		'script',
1977		'section',
1978		'select',
1979		'source',
1980		'style',
1981		'summary',
1982		'table',
1983		'tbody',
1984		'td',
1985		'textarea',
1986		'tfoot',
1987		'th',
1988		'thead',
1989		'title',
1990		'tr',
1991		'track',
1992		'ul',
1993		'wbr',
1994		'xmp'
1995	],
1996	"http://www.w3.org/1998/Math/MathML": [
1997		'mi',
1998		'mo',
1999		'mn',
2000		'ms',
2001		'mtext',
2002		'annotation-xml'
2003	],
2004	"http://www.w3.org/2000/svg": [
2005		'foreignObject',
2006		'desc',
2007		'title'
2008	]
2009};
2010
2011
2012function StackItem(namespaceURI, localName, attributes, node) {
2013	this.localName = localName;
2014	this.namespaceURI = namespaceURI;
2015	this.attributes = attributes;
2016	this.node = node;
2017}
2018StackItem.prototype.isSpecial = function() {
2019	return this.namespaceURI in SpecialElements &&
2020		SpecialElements[this.namespaceURI].indexOf(this.localName) > -1;
2021};
2022
2023StackItem.prototype.isFosterParenting = function() {
2024	if (this.namespaceURI === "http://www.w3.org/1999/xhtml") {
2025		return this.localName === 'table' ||
2026			this.localName === 'tbody' ||
2027			this.localName === 'tfoot' ||
2028			this.localName === 'thead' ||
2029			this.localName === 'tr';
2030	}
2031	return false;

2032};
2033
2034StackItem.prototype.isNumberedHeader = function() {
2035	if (this.namespaceURI === "http://www.w3.org/1999/xhtml") {
2036		return this.localName === 'h1' ||
2037			this.localName === 'h2' ||
2038			this.localName === 'h3' ||
2039			this.localName === 'h4' ||
2040			this.localName === 'h5' ||
2041			this.localName === 'h6';
2042	}
2043	return false;
2044};
2045
2046StackItem.prototype.isForeign = function() {
2047	return this.namespaceURI != "http://www.w3.org/1999/xhtml";
2048};
2049
2050function getAttribute(item, name) {
2051	for (var i = 0; i < item.attributes.length; i++) {
2052		if (item.attributes[i].nodeName == name)
2053			return item.attributes[i].nodeValue;
2054	}
2055	return null;
2056}
2057
2058StackItem.prototype.isHtmlIntegrationPoint = function() {
2059	if (this.namespaceURI === "http://www.w3.org/1998/Math/MathML") {
2060		if (this.localName !== "annotation-xml")
2061			return false;
2062		var encoding = getAttribute(this, 'encoding');
2063		if (!encoding)
2064			return false;
2065		encoding = encoding.toLowerCase();
2066		return encoding === "text/html" || encoding === "application/xhtml+xml";
2067	}
2068	if (this.namespaceURI === "http://www.w3.org/2000/svg") {
2069		return this.localName === "foreignObject"
2070			|| this.localName === "desc"
2071			|| this.localName === "title";
2072	}
2073	return false;
2074};
2075
2076StackItem.prototype.isMathMLTextIntegrationPoint = function() {
2077	if (this.namespaceURI === "http://www.w3.org/1998/Math/MathML") {
2078		return this.localName === "mi"
2079			|| this.localName === "mo"
2080			|| this.localName === "mn"
2081			|| this.localName === "ms"
2082			|| this.localName === "mtext";
2083	}
2084	return false;
2085};
2086
2087exports.StackItem = StackItem;
2088
2089},
2090{}],
20915:[function(_dereq_,module,exports){
2092var InputStream = _dereq_('./InputStream').InputStream;
2093var EntityParser = _dereq_('./EntityParser').EntityParser;
2094
2095function isWhitespace(c){
2096	return c === " " || c === "\n" || c === "\t" || c === "\r" || c === "\f";
2097}
2098
2099function isAlpha(c) {
2100	return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
2101}
2102function Tokenizer(tokenHandler) {
2103	this._tokenHandler = tokenHandler;
2104	this._state = Tokenizer.DATA;
2105	this._inputStream = new InputStream();
2106	this._currentToken = null;
2107	this._temporaryBuffer = '';
2108	this._additionalAllowedCharacter = '';
2109}
2110
2111Tokenizer.prototype._parseError = function(code, args) {
2112	this._tokenHandler.parseError(code, args);
2113};
2114
2115Tokenizer.prototype._emitToken = function(token) {
2116	if (token.type === 'StartTag') {
2117		for (var i = 1; i < token.data.length; i++) {
2118			if (!token.data[i].nodeName)
2119				token.data.splice(i--, 1);
2120		}
2121	} else if (token.type === 'EndTag') {
2122		if (token.selfClosing) {
2123			this._parseError('self-closing-flag-on-end-tag');
2124		}
2125		if (token.data.length !== 0) {
2126			this._parseError('attributes-in-end-tag');
2127		}
2128	}
2129	this._tokenHandler.processToken(token);
2130	if (token.type === 'StartTag' && token.selfClosing && !this._tokenHandler.isSelfClosingFlagAcknowledged()) {
2131		this._parseError('non-void-element-with-trailing-solidus', {name: token.name});
2132	}
2133};
2134
2135Tokenizer.prototype._emitCurrentToken = function() {
2136	this._state = Tokenizer.DATA;
2137	this._emitToken(this._currentToken);
2138};
2139
2140Tokenizer.prototype._currentAttribute = function() {
2141	return this._currentToken.data[this._currentToken.data.length - 1];
2142};
2143
2144Tokenizer.prototype.setState = function(state) {
2145	this._state = state;
2146};
2147
2148Tokenizer.prototype.tokenize = function(source) {
2149	Tokenizer.DATA = data_state;
2150	Tokenizer.RCDATA = rcdata_state;
2151	Tokenizer.RAWTEXT = rawtext_state;
2152	Tokenizer.SCRIPT_DATA = script_data_state;
2153	Tokenizer.PLAINTEXT = plaintext_state;
2154
2155
2156	this._state = Tokenizer.DATA;
2157
2158	this._inputStream.append(source);
2159
2160	this._tokenHandler.startTokenization(this);
2161
2162	this._inputStream.eof = true;
2163
2164	var tokenizer = this;
2165
2166	while (this._state.call(this, this._inputStream));
2167
2168
2169	function data_state(buffer) {
2170		var data = buffer.char();
2171		if (data === InputStream.EOF) {
2172			tokenizer._emitToken({type: 'EOF', data: null});
2173			return false;
2174		} else if (data === '&') {
2175			tokenizer.setState(character_reference_in_data_state);
2176		} else if (data === '<') {
2177			tokenizer.setState(tag_open_state);
2178		} else if (data === '\u0000') {
2179			tokenizer._emitToken({type: 'Characters', data: data});
2180			buffer.commit();
2181		} else {
2182			var chars = buffer.matchUntil("&|<|\u0000");
2183			tokenizer._emitToken({type: 'Characters', data: data + chars});
2184			buffer.commit();
2185		}
2186		return true;
2187	}
2188
2189	function character_reference_in_data_state(buffer) {
2190		var character = EntityParser.consumeEntity(buffer, tokenizer);
2191		tokenizer.setState(data_state);
2192		tokenizer._emitToken({type: 'Characters', data: character || '&'});
2193		return true;
2194	}
2195
2196	function rcdata_state(buffer) {
2197		var data = buffer.char();
2198		if (data === InputStream.EOF) {
2199			tokenizer._emitToken({type: 'EOF', data: null});
2200			return false;

2201		} else if (data === '&') {
2202			tokenizer.setState(character_reference_in_rcdata_state);
2203		} else if (data === '<') {
2204			tokenizer.setState(rcdata_less_than_sign_state);
2205		} else if (data === "\u0000") {
2206			tokenizer._parseError("invalid-codepoint");
2207			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2208			buffer.commit();
2209		} else {
2210			var chars = buffer.matchUntil("&|<|\u0000");
2211			tokenizer._emitToken({type: 'Characters', data: data + chars});
2212			buffer.commit();
2213		}
2214		return true;
2215	}
2216
2217	function character_reference_in_rcdata_state(buffer) {
2218		var character = EntityParser.consumeEntity(buffer, tokenizer);
2219		tokenizer.setState(rcdata_state);
2220		tokenizer._emitToken({type: 'Characters', data: character || '&'});
2221		return true;
2222	}
2223
2224	function rawtext_state(buffer) {
2225		var data = buffer.char();
2226		if (data === InputStream.EOF) {
2227			tokenizer._emitToken({type: 'EOF', data: null});
2228			return false;
2229		} else if (data === '<') {
2230			tokenizer.setState(rawtext_less_than_sign_state);
2231		} else if (data === "\u0000") {
2232			tokenizer._parseError("invalid-codepoint");
2233			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2234			buffer.commit();
2235		} else {
2236			var chars = buffer.matchUntil("<|\u0000");
2237			tokenizer._emitToken({type: 'Characters', data: data + chars});
2238		}
2239		return true;
2240	}
2241
2242	function plaintext_state(buffer) {
2243		var data = buffer.char();
2244		if (data === InputStream.EOF) {
2245			tokenizer._emitToken({type: 'EOF', data: null});
2246			return false;
2247		} else if (data === "\u0000") {
2248			tokenizer._parseError("invalid-codepoint");
2249			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2250			buffer.commit();
2251		} else {
2252			var chars = buffer.matchUntil("\u0000");
2253			tokenizer._emitToken({type: 'Characters', data: data + chars});
2254		}
2255		return true;
2256	}
2257
2258
2259	function script_data_state(buffer) {
2260		var data = buffer.char();
2261		if (data === InputStream.EOF) {
2262			tokenizer._emitToken({type: 'EOF', data: null});
2263			return false;
2264		} else if (data === '<') {
2265			tokenizer.setState(script_data_less_than_sign_state);
2266		} else if (data === '\u0000') {
2267			tokenizer._parseError("invalid-codepoint");
2268			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2269			buffer.commit();
2270		} else {
2271			var chars = buffer.matchUntil("<|\u0000");
2272			tokenizer._emitToken({type: 'Characters', data: data + chars});
2273		}
2274		return true;
2275	}
2276
2277	function rcdata_less_than_sign_state(buffer) {
2278		var data = buffer.char();
2279		if (data === "/") {
2280			this._temporaryBuffer = '';
2281			tokenizer.setState(rcdata_end_tag_open_state);
2282		} else {
2283			tokenizer._emitToken({type: 'Characters', data: '<'});
2284			buffer.unget(data);
2285			tokenizer.setState(rcdata_state);
2286		}
2287		return true;
2288	}
2289
2290	function rcdata_end_tag_open_state(buffer) {
2291		var data = buffer.char();
2292		if (isAlpha(data)) {
2293			this._temporaryBuffer += data;
2294			tokenizer.setState(rcdata_end_tag_name_state);
2295		} else {
2296			tokenizer._emitToken({type: 'Characters', data: '</'});
2297			buffer.unget(data);
2298			tokenizer.setState(rcdata_state);
2299		}
2300		return true;
2301	}
2302
2303	function rcdata_end_tag_name_state(buffer) {
2304		var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase());
2305		var data = buffer.char();
2306		if (isWhitespace(data) && appropriate) {
2307			tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false};
2308			tokenizer.setState(before_attribute_name_state);
2309		} else if (data === '/' && appropriate) {
2310			tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false};
2311			tokenizer.setState(self_closing_tag_state);
2312		} else if (data === '>' && appropriate) {
2313			tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false};
2314			tokenizer._emitCurrentToken();
2315			tokenizer.setState(data_state);
2316		} else if (isAlpha(data)) {
2317			this._temporaryBuffer += data;
2318			buffer.commit();
2319		} else {
2320			tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer});
2321			buffer.unget(data);
2322			tokenizer.setState(rcdata_state);
2323		}
2324		return true;
2325	}
2326
2327	function rawtext_less_than_sign_state(buffer) {
2328		var data = buffer.char();
2329		if (data === "/") {
2330			this._temporaryBuffer = '';
2331			tokenizer.setState(rawtext_end_tag_open_state);
2332		} else {
2333			tokenizer._emitToken({type: 'Characters', data: '<'});

2334			buffer.unget(data);
2335			tokenizer.setState(rawtext_state);
2336		}
2337		return true;
2338	}
2339
2340	function rawtext_end_tag_open_state(buffer) {
2341		var data = buffer.char();
2342		if (isAlpha(data)) {
2343			this._temporaryBuffer += data;
2344			tokenizer.setState(rawtext_end_tag_name_state);
2345		} else {
2346			tokenizer._emitToken({type: 'Characters', data: '</'});
2347			buffer.unget(data);
2348			tokenizer.setState(rawtext_state);
2349		}
2350		return true;
2351	}
2352
2353	function rawtext_end_tag_name_state(buffer) {
2354		var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase());
2355		var data = buffer.char();
2356		if (isWhitespace(data) && appropriate) {
2357			tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false};
2358			tokenizer.setState(before_attribute_name_state);
2359		} else if (data === '/' && appropriate) {
2360			tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false};
2361			tokenizer.setState(self_closing_tag_state);
2362		} else if (data === '>' && appropriate) {
2363			tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false};
2364			tokenizer._emitCurrentToken();
2365			tokenizer.setState(data_state);
2366		} else if (isAlpha(data)) {
2367			this._temporaryBuffer += data;
2368			buffer.commit();
2369		} else {
2370			tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer});
2371			buffer.unget(data);
2372			tokenizer.setState(rawtext_state);
2373		}
2374		return true;
2375	}
2376
2377	function script_data_less_than_sign_state(buffer) {
2378		var data = buffer.char();
2379		if (data === "/") {
2380			this._temporaryBuffer = '';
2381			tokenizer.setState(script_data_end_tag_open_state);
2382		} else if (data === '!') {
2383			tokenizer._emitToken({type: 'Characters', data: '<!'});
2384			tokenizer.setState(script_data_escape_start_state);
2385		} else {
2386			tokenizer._emitToken({type: 'Characters', data: '<'});
2387			buffer.unget(data);
2388			tokenizer.setState(script_data_state);
2389		}
2390		return true;
2391	}
2392
2393	function script_data_end_tag_open_state(buffer) {
2394		var data = buffer.char();
2395		if (isAlpha(data)) {
2396			this._temporaryBuffer += data;
2397			tokenizer.setState(script_data_end_tag_name_state);
2398		} else {
2399			tokenizer._emitToken({type: 'Characters', data: '</'});
2400			buffer.unget(data);
2401			tokenizer.setState(script_data_state);
2402		}
2403		return true;
2404	}
2405
2406	function script_data_end_tag_name_state(buffer) {
2407		var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase());
2408		var data = buffer.char();
2409		if (isWhitespace(data) && appropriate) {
2410			tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false};
2411			tokenizer.setState(before_attribute_name_state);
2412		} else if (data === '/' && appropriate) {
2413			tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false};
2414			tokenizer.setState(self_closing_tag_state);
2415		} else if (data === '>' && appropriate) {
2416			tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false};
2417			tokenizer._emitCurrentToken();
2418		} else if (isAlpha(data)) {
2419			this._temporaryBuffer += data;
2420			buffer.commit();
2421		} else {
2422			tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer});
2423			buffer.unget(data);
2424			tokenizer.setState(script_data_state);
2425		}
2426		return true;
2427	}
2428
2429	function script_data_escape_start_state(buffer) {
2430		var data = buffer.char();
2431		if (data === '-') {
2432			tokenizer._emitToken({type: 'Characters', data: '-'});
2433			tokenizer.setState(script_data_escape_start_dash_state);
2434		} else {
2435			buffer.unget(data);
2436			tokenizer.setState(script_data_state);
2437		}
2438		return true;
2439	}
2440
2441	function script_data_escape_start_dash_state(buffer) {
2442		var data = buffer.char();
2443		if (data === '-') {
2444			tokenizer._emitToken({type: 'Characters', data: '-'});
2445			tokenizer.setState(script_data_escaped_dash_dash_state);
2446		} else {
2447			buffer.unget(data);
2448			tokenizer.setState(script_data_state);
2449		}
2450		return true;
2451	}
2452
2453	function script_data_escaped_state(buffer) {
2454		var data = buffer.char();
2455		if (data === InputStream.EOF) {

2456			buffer.unget(data);
2457			tokenizer.setState(data_state);
2458		} else if (data === '-') {
2459			tokenizer._emitToken({type: 'Characters', data: '-'});
2460			tokenizer.setState(script_data_escaped_dash_state);
2461		} else if (data === '<') {
2462			tokenizer.setState(script_data_escaped_less_then_sign_state);
2463		} else if (data === '\u0000') {
2464			tokenizer._parseError("invalid-codepoint");
2465			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2466			buffer.commit();
2467		} else {
2468			var chars = buffer.matchUntil('<|-|\u0000');
2469			tokenizer._emitToken({type: 'Characters', data: data + chars});
2470		}
2471		return true;
2472	}
2473
2474	function script_data_escaped_dash_state(buffer) {
2475		var data = buffer.char();
2476		if (data === InputStream.EOF) {
2477			buffer.unget(data);
2478			tokenizer.setState(data_state);
2479		} else if (data === '-') {
2480			tokenizer._emitToken({type: 'Characters', data: '-'});
2481			tokenizer.setState(script_data_escaped_dash_dash_state);
2482		} else if (data === '<') {
2483			tokenizer.setState(script_data_escaped_less_then_sign_state);
2484		} else if (data === '\u0000') {
2485			tokenizer._parseError("invalid-codepoint");
2486			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2487			tokenizer.setState(script_data_escaped_state);
2488		} else {
2489			tokenizer._emitToken({type: 'Characters', data: data});
2490			tokenizer.setState(script_data_escaped_state);
2491		}
2492		return true;
2493	}
2494
2495	function script_data_escaped_dash_dash_state(buffer) {
2496		var data = buffer.char();
2497		if (data === InputStream.EOF) {
2498			tokenizer._parseError('eof-in-script');
2499			buffer.unget(data);
2500			tokenizer.setState(data_state);
2501		} else if (data === '<') {
2502			tokenizer.setState(script_data_escaped_less_then_sign_state);
2503		} else if (data === '>') {
2504			tokenizer._emitToken({type: 'Characters', data: '>'});
2505			tokenizer.setState(script_data_state);
2506		} else if (data === '\u0000') {
2507			tokenizer._parseError("invalid-codepoint");
2508			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2509			tokenizer.setState(script_data_escaped_state);
2510		} else {
2511			tokenizer._emitToken({type: 'Characters', data: data});
2512			tokenizer.setState(script_data_escaped_state);
2513		}
2514		return true;
2515	}
2516
2517	function script_data_escaped_less_then_sign_state(buffer) {
2518		var data = buffer.char();
2519		if (data === '/') {
2520			this._temporaryBuffer = '';
2521			tokenizer.setState(script_data_escaped_end_tag_open_state);
2522		} else if (isAlpha(data)) {
2523			tokenizer._emitToken({type: 'Characters', data: '<' + data});
2524			this._temporaryBuffer = data;
2525			tokenizer.setState(script_data_double_escape_start_state);
2526		} else {
2527			tokenizer._emitToken({type: 'Characters', data: '<'});
2528			buffer.unget(data);
2529			tokenizer.setState(script_data_escaped_state);
2530		}
2531		return true;
2532	}
2533
2534	function script_data_escaped_end_tag_open_state(buffer) {
2535		var data = buffer.char();
2536		if (isAlpha(data)) {
2537			this._temporaryBuffer = data;
2538			tokenizer.setState(script_data_escaped_end_tag_name_state);
2539		} else {
2540			tokenizer._emitToken({type: 'Characters', data: '</'});
2541			buffer.unget(data);
2542			tokenizer.setState(script_data_escaped_state);
2543		}
2544		return true;
2545	}
2546
2547	function script_data_escaped_end_tag_name_state(buffer) {
2548		var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase());
2549		var data = buffer.char();
2550		if (isWhitespace(data) && appropriate) {
2551			tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false};
2552			tokenizer.setState(before_attribute_name_state);
2553		} else if (data === '/' && appropriate) {
2554			tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false};
2555			tokenizer.setState(self_closing_tag_state);
2556		} else if (data === '>' &&  appropriate) {
2557			tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false};
2558			tokenizer.setState(data_state);
2559			tokenizer._emitCurrentToken();
2560		} else if (isAlpha(data)) {
2561			this._temporaryBuffer += data;
2562			buffer.commit();
2563		} else {
2564			tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer});
2565			buffer.unget(data);
2566			tokenizer.setState(script_data_escaped_state);
2567		}
2568		return true;
2569	}
2570
2571	function script_data_double_escape_start_state(buffer) {
2572		var data = buffer.char();
2573		if (isWhitespace(data) || data === '/' || data === '>') {
2574			tokenizer._emitToken({type: 'Characters', data: data});
2575			if (this._temporaryBuffer.toLowerCase() === 'script')
2576				tokenizer.setState(script_data_double_escaped_state);
2577			else
2578				tokenizer.setState(script_data_escaped_state);
2579		} else if (isAlpha(data)) {
2580			tokenizer._emitToken({type: 'Characters', data: data});
2581			this._temporaryBuffer += data;
2582			buffer.commit();
2583		} else {

2584			buffer.unget(data);
2585			tokenizer.setState(script_data_escaped_state);
2586		}
2587		return true;
2588	}
2589
2590	function script_data_double_escaped_state(buffer) {
2591		var data = buffer.char();
2592		if (data === InputStream.EOF) {
2593			tokenizer._parseError('eof-in-script');
2594			buffer.unget(data);
2595			tokenizer.setState(data_state);
2596		} else if (data === '-') {
2597			tokenizer._emitToken({type: 'Characters', data: '-'});
2598			tokenizer.setState(script_data_double_escaped_dash_state);
2599		} else if (data === '<') {
2600			tokenizer._emitToken({type: 'Characters', data: '<'});
2601			tokenizer.setState(script_data_double_escaped_less_than_sign_state);
2602		} else if (data === '\u0000') {
2603			tokenizer._parseError('invalid-codepoint');
2604			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2605			buffer.commit();
2606		} else {
2607			tokenizer._emitToken({type: 'Characters', data: data});
2608			buffer.commit();
2609		}
2610		return true;
2611	}
2612
2613	function script_data_double_escaped_dash_state(buffer) {
2614		var data = buffer.char();
2615		if (data === InputStream.EOF) {
2616			tokenizer._parseError('eof-in-script');
2617			buffer.unget(data);
2618			tokenizer.setState(data_state);
2619		} else if (data === '-') {
2620			tokenizer._emitToken({type: 'Characters', data: '-'});
2621			tokenizer.setState(script_data_double_escaped_dash_dash_state);
2622		} else if (data === '<') {
2623			tokenizer._emitToken({type: 'Characters', data: '<'});
2624			tokenizer.setState(script_data_double_escaped_less_than_sign_state);
2625		} else if (data === '\u0000') {
2626			tokenizer._parseError('invalid-codepoint');
2627			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2628			tokenizer.setState(script_data_double_escaped_state);
2629		} else {
2630			tokenizer._emitToken({type: 'Characters', data: data});
2631			tokenizer.setState(script_data_double_escaped_state);
2632		}
2633		return true;
2634	}
2635
2636	function script_data_double_escaped_dash_dash_state(buffer) {
2637		var data = buffer.char();
2638		if (data === InputStream.EOF) {
2639			tokenizer._parseError('eof-in-script');
2640			buffer.unget(data);
2641			tokenizer.setState(data_state);
2642		} else if (data === '-') {
2643			tokenizer._emitToken({type: 'Characters', data: '-'});
2644			buffer.commit();
2645		} else if (data === '<') {
2646			tokenizer._emitToken({type: 'Characters', data: '<'});
2647			tokenizer.setState(script_data_double_escaped_less_than_sign_state);
2648		} else if (data === '>') {
2649			tokenizer._emitToken({type: 'Characters', data: '>'});
2650			tokenizer.setState(script_data_state);
2651		} else if (data === '\u0000') {
2652			tokenizer._parseError('invalid-codepoint');
2653			tokenizer._emitToken({type: 'Characters', data: '\uFFFD'});
2654			tokenizer.setState(script_data_double_escaped_state);
2655		} else {
2656			tokenizer._emitToken({type: 'Characters', data: data});
2657			tokenizer.setState(script_data_double_escaped_state);
2658		}
2659		return true;
2660	}
2661
2662	function script_data_double_escaped_less_than_sign_state(buffer) {
2663		var data = buffer.char();
2664		if (data === '/') {
2665			tokenizer._emitToken({type: 'Characters', data: '/'});
2666			this._temporaryBuffer = '';
2667			tokenizer.setState(script_data_double_escape_end_state);
2668		} else {
2669			buffer.unget(data);
2670			tokenizer.setState(script_data_double_escaped_state);
2671		}
2672		return true;
2673	}
2674
2675	function script_data_double_escape_end_state(buffer) {
2676		var data = buffer.char();
2677		if (isWhitespace(data) || data === '/' || data === '>') {
2678			tokenizer._emitToken({type: 'Characters', data: data});
2679			if (this._temporaryBuffer.toLowerCase() === 'script')
2680				tokenizer.setState(script_data_escaped_state);
2681			else
2682				tokenizer.setState(script_data_double_escaped_state);
2683		} else if (isAlpha(data)) {
2684			tokenizer._emitToken({type: 'Characters', data: data});
2685			this._temporaryBuffer += data;
2686			buffer.commit();
2687		} else {
2688			buffer.unget(data);
2689			tokenizer.setState(script_data_double_escaped_state);
2690		}
2691		return true;
2692	}
2693
2694	function tag_open_state(buffer) {
2695		var data = buffer.char();
2696		if (data === InputStream.EOF) {
2697			tokenizer._parseError("bare-less-than-sign-at-eof");
2698			tokenizer._emitToken({type: 'Characters', data: '<'});
2699			buffer.unget(data);
2700			tokenizer.setState(data_state);
2701		} else if (isAlpha(data)) {
2702			tokenizer._currentToken = {type: 'StartTag', name: data.toLowerCase(), data: []};
2703			tokenizer.setState(tag_name_state);
2704		} else if (data === '!') {
2705			tokenizer.setState(markup_declaration_open_state);
2706		} else if (data === '/') {
2707			tokenizer.setState(close_tag_open_state);
2708		} else if (data === '>') {
2709			tokenizer._parseError("expected-tag-name-but-got-right-bracket");
2710			tokenizer._emitToken({type: 'Characters', data: "<>"});
2711			tokenizer.setState(data_state);
2712		} else if (data === '?') {
2713			tokenizer._parseError("expected-tag-name-but-got-question-mark");

2714			buffer.unget(data);
2715			tokenizer.setState(bogus_comment_state);
2716		} else {
2717			tokenizer._parseError("expected-tag-name");
2718			tokenizer._emitToken({type: 'Characters', data: "<"});
2719			buffer.unget(data);
2720			tokenizer.setState(data_state);
2721		}
2722		return true;
2723	}
2724
2725	function close_tag_open_state(buffer) {
2726		var data = buffer.char();
2727		if (data === InputStream.EOF) {
2728			tokenizer._parseError("expected-closing-tag-but-got-eof");
2729			tokenizer._emitToken({type: 'Characters', data: '</'});
2730			buffer.unget(data);
2731			tokenizer.setState(data_state);
2732		} else if (isAlpha(data)) {
2733			tokenizer._currentToken = {type: 'EndTag', name: data.toLowerCase(), data: []};
2734			tokenizer.setState(tag_name_state);
2735		} else if (data === '>') {
2736			tokenizer._parseError("expected-closing-tag-but-got-right-bracket");
2737			tokenizer.setState(data_state);
2738		} else {
2739			tokenizer._parseError("expected-closing-tag-but-got-char", {data: data}); // param 1 is datavars:
2740			buffer.unget(data);
2741			tokenizer.setState(bogus_comment_state);
2742		}
2743		return true;
2744	}
2745
2746	function tag_name_state(buffer) {
2747		var data = buffer.char();
2748		if (data === InputStream.EOF) {
2749			tokenizer._parseError('eof-in-tag-name');
2750			buffer.unget(data);
2751			tokenizer.setState(data_state);
2752		} else if (isWhitespace(data)) {
2753			tokenizer.setState(before_attribute_name_state);
2754		} else if (isAlpha(data)) {
2755			tokenizer._currentToken.name += data.toLowerCase();
2756		} else if (data === '>') {
2757			tokenizer._emitCurrentToken();
2758		} else if (data === '/') {
2759			tokenizer.setState(self_closing_tag_state);
2760		} else if (data === '\u0000') {
2761			tokenizer._parseError("invalid-codepoint");
2762			tokenizer._currentToken.name += "\uFFFD";
2763		} else {
2764			tokenizer._currentToken.name += data;
2765		}
2766		buffer.commit();
2767
2768		return true;
2769	}
2770
2771	function before_attribute_name_state(buffer) {
2772		var data = buffer.char();
2773		if (data === InputStream.EOF) {
2774			tokenizer._parseError("expected-attribute-name-but-got-eof");
2775			buffer.unget(data);
2776			tokenizer.setState(data_state);
2777		} else if (isWhitespace(data)) {
2778			return true;
2779		} else if (isAlpha(data)) {
2780			tokenizer._currentToken.data.push({nodeName: data.toLowerCase(), nodeValue: ""});
2781			tokenizer.setState(attribute_name_state);
2782		} else if (data === '>') {
2783			tokenizer._emitCurrentToken();
2784		} else if (data === '/') {
2785			tokenizer.setState(self_closing_tag_state);
2786		} else if (data === "'" || data === '"' || data === '=' || data === '<') {
2787			tokenizer._parseError("invalid-character-in-attribute-name");
2788			tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""});
2789			tokenizer.setState(attribute_name_state);
2790		} else if (data === '\u0000') {
2791			tokenizer._parseError("invalid-codepoint");
2792			tokenizer._currentToken.data.push({nodeName: "\uFFFD", nodeValue: ""});
2793		} else {
2794			tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""});
2795			tokenizer.setState(attribute_name_state);
2796		}
2797		return true;
2798	}
2799
2800	function attribute_name_state(buffer) {
2801		var data = buffer.char();
2802		var leavingThisState = true;
2803		var shouldEmit = false;
2804		if (data === InputStream.EOF) {
2805			tokenizer._parseError("eof-in-attribute-name");
2806			buffer.unget(data);
2807			tokenizer.setState(data_state);
2808			shouldEmit = true;
2809		} else if (data === '=') {
2810			tokenizer.setState(before_attribute_value_state);
2811		} else if (isAlpha(data)) {
2812			tokenizer._currentAttribute().nodeName += data.toLowerCase();
2813			leavingThisState = false;
2814		} else if (data === '>') {
2815			shouldEmit = true;
2816		} else if (isWhitespace(data)) {
2817			tokenizer.setState(after_attribute_name_state);
2818		} else if (data === '/') {
2819			tokenizer.setState(self_closing_tag_state);
2820		} else if (data === "'" || data === '"') {
2821			tokenizer._parseError("invalid-character-in-attribute-name");
2822			tokenizer._currentAttribute().nodeName += data;
2823			leavingThisState = false;
2824		} else if (data === '\u0000') {
2825			tokenizer._parseError("invalid-codepoint");
2826			tokenizer._currentAttribute().nodeName += "\uFFFD";
2827		} else {
2828			tokenizer._currentAttribute().nodeName += data;
2829			leavingThisState = false;
2830		}
2831
2832		if (leavingThisState) {
2833			var attributes = tokenizer._currentToken.data;
2834			var currentAttribute = attributes[attributes.length - 1];
2835			for (var i = attributes.length - 2; i >= 0; i--) {

2836				if (currentAttribute.nodeName === attributes[i].nodeName) {
2837					tokenizer._parseError("duplicate-attribute", {name: currentAttribute.nodeName});
2838					currentAttribute.nodeName = null;
2839					break;
2840				}
2841			}
2842			if (shouldEmit)
2843				tokenizer._emitCurrentToken();
2844		} else {
2845			buffer.commit();
2846		}
2847		return true;
2848	}
2849
2850	function after_attribute_name_state(buffer) {
2851		var data = buffer.char();
2852		if (data === InputStream.EOF) {
2853			tokenizer._parseError("expected-end-of-tag-but-got-eof");
2854			buffer.unget(data);
2855			tokenizer.setState(data_state);
2856		} else if (isWhitespace(data)) {
2857			return true;
2858		} else if (data === '=') {
2859			tokenizer.setState(before_attribute_value_state);
2860		} else if (data === '>') {
2861			tokenizer._emitCurrentToken();
2862		} else if (isAlpha(data)) {
2863			tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""});
2864			tokenizer.setState(attribute_name_state);
2865		} else if (data === '/') {
2866			tokenizer.setState(self_closing_tag_state);
2867		} else if (data === "'" || data === '"' || data === '<') {
2868			tokenizer._parseError("invalid-character-after-attribute-name");
2869			tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""});
2870			tokenizer.setState(attribute_name_state);
2871		} else if (data === '\u0000') {
2872			tokenizer._parseError("invalid-codepoint");
2873			tokenizer._currentToken.data.push({nodeName: "\uFFFD", nodeValue: ""});
2874		} else {
2875			tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""});
2876			tokenizer.setState(attribute_name_state);
2877		}
2878		return true;
2879	}
2880
2881	function before_attribute_value_state(buffer) {
2882		var data = buffer.char();
2883		if (data === InputStream.EOF) {
2884			tokenizer._parseError("expected-attribute-value-but-got-eof");
2885			buffer.unget(data);
2886			tokenizer.setState(data_state);
2887		} else if (isWhitespace(data)) {
2888			return true;
2889		} else if (data === '"') {
2890			tokenizer.setState(attribute_value_double_quoted_state);
2891		} else if (data === '&') {
2892			tokenizer.setState(attribute_value_unquoted_state);
2893			buffer.unget(data);
2894		} else if (data === "'") {
2895			tokenizer.setState(attribute_value_single_quoted_state);
2896		} else if (data === '>') {
2897			tokenizer._parseError("expected-attribute-value-but-got-right-bracket");
2898			tokenizer._emitCurrentToken();
2899		} else if (data === '=' || data === '<' || data === '`') {
2900			tokenizer._parseError("unexpected-character-in-unquoted-attribute-value");
2901			tokenizer._currentAttribute().nodeValue += data;
2902			tokenizer.setState(attribute_value_unquoted_state);
2903		} else if (data === '\u0000') {
2904			tokenizer._parseError("invalid-codepoint");
2905			tokenizer._currentAttribute().nodeValue += "\uFFFD";
2906		} else {
2907			tokenizer._currentAttribute().nodeValue += data;
2908			tokenizer.setState(attribute_value_unquoted_state);
2909		}
2910
2911		return true;
2912	}
2913
2914	function attribute_value_double_quoted_state(buffer) {
2915		var data = buffer.char();
2916		if (data === InputStream.EOF) {
2917			tokenizer._parseError("eof-in-attribute-value-double-quote");
2918			buffer.unget(data);
2919			tokenizer.setState(data_state);
2920		} else if (data === '"') {
2921			tokenizer.setState(after_attribute_value_state);
2922		} else if (data === '&') {
2923			this._additionalAllowedCharacter = '"';
2924			tokenizer.setState(character_reference_in_attribute_value_state);
2925		} else if (data === '\u0000') {
2926			tokenizer._parseError("invalid-codepoint");
2927			tokenizer._currentAttribute().nodeValue += "\uFFFD";
2928		} else {
2929			var s = buffer.matchUntil('[\0"&]');
2930			data = data + s;
2931			tokenizer._currentAttribute().nodeValue += data;
2932		}
2933		return true;
2934	}
2935
2936	function attribute_value_single_quoted_state(buffer) {
2937		var data = buffer.char();
2938		if (data === InputStream.EOF) {
2939			tokenizer._parseError("eof-in-attribute-value-single-quote");
2940			buffer.unget(data);
2941			tokenizer.setState(data_state);
2942		} else if (data === "'") {
2943			tokenizer.setState(after_attribute_value_state);
2944		} else if (data === '&') {
2945			this._additionalAllowedCharacter = "'";
2946			tokenizer.setState(character_reference_in_attribute_value_state);
2947		} else if (data === '\u0000') {
2948			tokenizer._parseError("invalid-codepoint");
2949			tokenizer._currentAttribute().nodeValue += "\uFFFD";
2950		} else {
2951			tokenizer._currentAttribute().nodeValue += data + buffer.matchUntil("\u0000|['&]");
2952		}
2953		return true;
2954	}
2955
2956	function attribute_value_unquoted_state(buffer) {
2957		var data = buffer.char();
2958		if (data === InputStream.EOF) {
2959			tokenizer._parseError("eof-after-attribute-value");

2960			buffer.unget(data);
2961			tokenizer.setState(data_state);
2962		} else if (isWhitespace(data)) {
2963			tokenizer.setState(before_attribute_name_state);
2964		} else if (data === '&') {
2965			this._additionalAllowedCharacter = ">";
2966			tokenizer.setState(character_reference_in_attribute_value_state);
2967		} else if (data === '>') {
2968			tokenizer._emitCurrentToken();
2969		} else if (data === '"' || data === "'" || data === '=' || data === '`' || data === '<') {
2970			tokenizer._parseError("unexpected-character-in-unquoted-attribute-value");
2971			tokenizer._currentAttribute().nodeValue += data;
2972			buffer.commit();
2973		} else if (data === '\u0000') {
2974			tokenizer._parseError("invalid-codepoint");
2975			tokenizer._currentAttribute().nodeValue += "\uFFFD";
2976		} else {
2977			var o = buffer.matchUntil("\u0000|["+ "\t\n\v\f\x20\r" + "&<>\"'=`" +"]");
2978			if (o === InputStream.EOF) {
2979				tokenizer._parseError("eof-in-attribute-value-no-quotes");
2980				tokenizer._emitCurrentToken();
2981			}
2982			buffer.commit();
2983			tokenizer._currentAttribute().nodeValue += data + o;
2984		}
2985		return true;
2986	}
2987
2988	function character_reference_in_attribute_value_state(buffer) {
2989		var character = EntityParser.consumeEntity(buffer, tokenizer, this._additionalAllowedCharacter);
2990		this._currentAttribute().nodeValue += character || '&';
2991		if (this._additionalAllowedCharacter === '"')
2992			tokenizer.setState(attribute_value_double_quoted_state);
2993		else if (this._additionalAllowedCharacter === '\'')
2994			tokenizer.setState(attribute_value_single_quoted_state);
2995		else if (this._additionalAllowedCharacter === '>')
2996			tokenizer.setState(attribute_value_unquoted_state);
2997		return true;
2998	}
2999
3000	function after_attribute_value_state(buffer) {
3001		var data = buffer.char();
3002		if (data === InputStream.EOF) {
3003			tokenizer._parseError("eof-after-attribute-value");
3004			buffer.unget(data);
3005			tokenizer.setState(data_state);
3006		} else if (isWhitespace(data)) {
3007			tokenizer.setState(before_attribute_name_state);
3008		} else if (data === '>') {
3009			tokenizer.setState(data_state);
3010			tokenizer._emitCurrentToken();
3011		} else if (data === '/') {
3012			tokenizer.setState(self_closing_tag_state);
3013		} else {
3014			tokenizer._parseError("unexpected-character-after-attribute-value");
3015			buffer.unget(data);
3016			tokenizer.setState(before_attribute_name_state);
3017		}
3018		return true;
3019	}
3020
3021	function self_closing_tag_state(buffer) {
3022		var c = buffer.char();
3023		if (c === InputStream.EOF) {
3024			tokenizer._parseError("unexpected-eof-after-solidus-in-tag");
3025			buffer.unget(c);
3026			tokenizer.setState(data_state);
3027		} else if (c === '>') {
3028			tokenizer._currentToken.selfClosing = true;
3029			tokenizer.setState(data_state);
3030			tokenizer._emitCurrentToken();
3031		} else {
3032			tokenizer._parseError("unexpected-character-after-solidus-in-tag");
3033			buffer.unget(c);
3034			tokenizer.setState(before_attribute_name_state);
3035		}
3036		return true;
3037	}
3038
3039	function bogus_comment_state(buffer) {
3040		var data = buffer.matchUntil('>');
3041		data = data.replace(/\u0000/g, "\uFFFD");
3042		buffer.char();
3043		tokenizer._emitToken({type: 'Comment', data: data});
3044		tokenizer.setState(data_state);
3045		return true;
3046	}
3047
3048	function markup_declaration_open_state(buffer) {
3049		var chars = buffer.shift(2);
3050		if (chars === '--') {
3051			tokenizer._currentToken = {type: 'Comment', data: ''};
3052			tokenizer.setState(comment_start_state);
3053		} else {
3054			var newchars = buffer.shift(5);
3055			if (newchars === InputStream.EOF || chars === InputStream.EOF) {
3056				tokenizer._parseError("expected-dashes-or-doctype");
3057				tokenizer.setState(bogus_comment_state);
3058				buffer.unget(chars);
3059				return true;
3060			}
3061
3062			chars += newchars;
3063			if (chars.toUpperCase() === 'DOCTYPE') {
3064				tokenizer._currentToken = {type: 'Doctype', name: '', publicId: null, systemId: null, forceQuirks: false};
3065				tokenizer.setState(doctype_state);
3066			} else if (tokenizer._tokenHandler.isCdataSectionAllowed() && chars === '[CDATA[') {
3067				tokenizer.setState(cdata_section_state);
3068			} else {
3069				tokenizer._parseError("expected-dashes-or-doctype");
3070				buffer.unget(chars);
3071				tokenizer.setState(bogus_comment_state);
3072			}
3073		}
3074		return true;
3075	}
3076
3077	function cdata_section_state(buffer) {
3078		var data = buffer.matchUntil(']]>');
3079		buffer.shift(3);
3080		if (data) {
3081			tokenizer._emitToken({type: 'Characters', data: data});
3082		}
3083		tokenizer.setState(data_state);
3084		return true;
3085	}
3086
3087	function comment_start_state(buffer) {
3088		var data = buffer.char();
3089		if (data === InputStream.EOF) {
3090			tokenizer._parseError("eof-in-comment");
3091			tokenizer._emitToken(tokenizer._currentToken);

3092			buffer.unget(data);
3093			tokenizer.setState(data_state);
3094		} else if (data === '-') {
3095			tokenizer.setState(comment_start_dash_state);
3096		} else if (data === '>') {
3097			tokenizer._parseError("incorrect-comment");
3098			tokenizer._emitToken(tokenizer._currentToken);
3099			tokenizer.setState(data_state);
3100		} else if (data === '\u0000') {
3101			tokenizer._parseError("invalid-codepoint");
3102			tokenizer._currentToken.data += "\uFFFD";
3103		} else {
3104			tokenizer._currentToken.data += data;
3105			tokenizer.setState(comment_state);
3106		}
3107		return true;
3108	}
3109
3110	function comment_start_dash_state(buffer) {
3111		var data = buffer.char();
3112		if (data === InputStream.EOF) {
3113			tokenizer._parseError("eof-in-comment");
3114			tokenizer._emitToken(tokenizer._currentToken);
3115			buffer.unget(data);
3116			tokenizer.setState(data_state);
3117		} else if (data === '-') {
3118			tokenizer.setState(comment_end_state);
3119		} else if (data === '>') {
3120			tokenizer._parseError("incorrect-comment");
3121			tokenizer._emitToken(tokenizer._currentToken);
3122			tokenizer.setState(data_state);
3123		} else if (data === '\u0000') {
3124			tokenizer._parseError("invalid-codepoint");
3125			tokenizer._currentToken.data += "\uFFFD";
3126		} else {
3127			tokenizer._currentToken.data += '-' + data;
3128			tokenizer.setState(comment_state);
3129		}
3130		return true;
3131	}
3132
3133	function comment_state(buffer) {
3134		var data = buffer.char();
3135		if (data === InputStream.EOF) {
3136			tokenizer._parseError("eof-in-comment");
3137			tokenizer._emitToken(tokenizer._currentToken);
3138			buffer.unget(data);
3139			tokenizer.setState(data_state);
3140		} else if (data === '-') {
3141			tokenizer.setState(comment_end_dash_state);
3142		} else if (data === '\u0000') {
3143			tokenizer._parseError("invalid-codepoint");
3144			tokenizer._currentToken.data += "\uFFFD";
3145		} else {
3146			tokenizer._currentToken.data += data;
3147			buffer.commit();
3148		}
3149		return true;
3150	}
3151
3152	function comment_end_dash_state(buffer) {
3153		var data = buffer.char();
3154		if (data === InputStream.EOF) {
3155			tokenizer._parseError("eof-in-comment-end-dash");
3156			tokenizer._emitToken(tokenizer._currentToken);
3157			buffer.unget(data);
3158			tokenizer.setState(data_state);
3159		} else if (data === '-') {
3160			tokenizer.setState(comment_end_state);
3161		} else if (data === '\u0000') {
3162			tokenizer._parseError("invalid-codepoint");
3163			tokenizer._currentToken.data += "-\uFFFD";
3164			tokenizer.setState(comment_state);
3165		} else {
3166			tokenizer._currentToken.data += '-' + data + buffer.matchUntil('\u0000|-');
3167			buffer.char();
3168		}
3169		return true;
3170	}
3171
3172	function comment_end_state(buffer) {
3173		var data = buffer.char();
3174		if (data === InputStream.EOF) {
3175			tokenizer._parseError("eof-in-comment-double-dash");
3176			tokenizer._emitToken(tokenizer._currentToken);
3177			buffer.unget(data);
3178			tokenizer.setState(data_state);
3179		} else if (data === '>') {
3180			tokenizer._emitToken(tokenizer._currentToken);
3181			tokenizer.setState(data_state);
3182		} else if (data === '!') {
3183			tokenizer._parseError("unexpected-bang-after-double-dash-in-comment");
3184			tokenizer.setState(comment_end_bang_state);
3185		} else if (data === '-') {
3186			tokenizer._parseError("unexpected-dash-after-double-dash-in-comment");
3187			tokenizer._currentToken.data += data;
3188		} else if (data === '\u0000') {
3189			tokenizer._parseError("invalid-codepoint");
3190			tokenizer._currentToken.data += "--\uFFFD";
3191			tokenizer.setState(comment_state);
3192		} else {
3193			tokenizer._parseError("unexpected-char-in-comment");
3194			tokenizer._currentToken.data += '--' + data;
3195			tokenizer.setState(comment_state);
3196		}
3197		return true;
3198	}
3199
3200	function comment_end_bang_state(buffer) {
3201		var data = buffer.char();
3202		if (data === InputStream.EOF) {
3203			tokenizer._parseError("eof-in-comment-end-bang-state");
3204			tokenizer._emitToken(tokenizer._currentToken);
3205			buffer.unget(data);
3206			tokenizer.setState(data_state);
3207		} else if (data === '>') {
3208			tokenizer._emitToken(tokenizer._currentToken);
3209			tokenizer.setState(data_state);
3210		} else if (data === '-') {
3211			tokenizer._currentToken.data += '--!';
3212			tokenizer.setState(comment_end_dash_state);
3213		} else {
3214			tokenizer._currentToken.data += '--!' + data;
3215			tokenizer.setState(comment_state);
3216		}
3217		return true;
3218	}
3219
3220	function doctype_state(buffer) {
3221		var data = buffer.char();
3222		if (data === InputStream.EOF) {
3223			tokenizer._parseError("expected-doctype-name-but-got-eof");
3224			tokenizer._currentToken.forceQuirks = true;

3225			buffer.unget(data);
3226			tokenizer.setState(data_state);
3227			tokenizer._emitCurrentToken();
3228		} else if (isWhitespace(data)) {
3229			tokenizer.setState(before_doctype_name_state);
3230		} else {
3231			tokenizer._parseError("need-space-after-doctype");
3232			buffer.unget(data);
3233			tokenizer.setState(before_doctype_name_state);
3234		}
3235		return true;
3236	}
3237
3238	function before_doctype_name_state(buffer) {
3239		var data = buffer.char();
3240		if (data === InputStream.EOF) {
3241			tokenizer._parseError("expected-doctype-name-but-got-eof");
3242			tokenizer._currentToken.forceQuirks = true;
3243			buffer.unget(data);
3244			tokenizer.setState(data_state);
3245			tokenizer._emitCurrentToken();
3246		} else if (isWhitespace(data)) {
3247		} else if (data === '>') {
3248			tokenizer._parseError("expected-doctype-name-but-got-right-bracket");
3249			tokenizer._currentToken.forceQuirks = true;
3250			tokenizer.setState(data_state);
3251			tokenizer._emitCurrentToken();
3252		} else {
3253			if (isAlpha(data))
3254				data = data.toLowerCase();
3255			tokenizer._currentToken.name = data;
3256			tokenizer.setState(doctype_name_state);
3257		}
3258		return true;
3259	}
3260
3261	function doctype_name_state(buffer) {
3262		var data = buffer.char();
3263		if (data === InputStream.EOF) {
3264			tokenizer._currentToken.forceQuirks = true;
3265			buffer.unget(data);
3266			tokenizer._parseError("eof-in-doctype-name");
3267			tokenizer.setState(data_state);
3268			tokenizer._emitCurrentToken();
3269		} else if (isWhitespace(data)) {
3270			tokenizer.setState(after_doctype_name_state);
3271		} else if (data === '>') {
3272			tokenizer.setState(data_state);
3273			tokenizer._emitCurrentToken();
3274		} else {
3275			if (isAlpha(data))
3276				data = data.toLowerCase();
3277			tokenizer._currentToken.name += data;
3278			buffer.commit();
3279		}
3280		return true;
3281	}
3282
3283	function after_doctype_name_state(buffer) {
3284		var data = buffer.char();
3285		if (data === InputStream.EOF) {
3286			tokenizer._currentToken.forceQuirks = true;
3287			buffer.unget(data);
3288			tokenizer._parseError("eof-in-doctype");
3289			tokenizer.setState(data_state);
3290			tokenizer._emitCurrentToken();
3291		} else if (isWhitespace(data)) {
3292		} else if (data === '>') {
3293			tokenizer.setState(data_state);
3294			tokenizer._emitCurrentToken();
3295		} else {
3296			if (['p', 'P'].indexOf(data) > -1) {
3297				var expected = [['u', 'U'], ['b', 'B'], ['l', 'L'], ['i', 'I'], ['c', 'C']];
3298				var matched = expected.every(function(expected){
3299					data = buffer.char();
3300					return expected.indexOf(data) > -1;
3301				});
3302				if (matched) {
3303					tokenizer.setState(after_doctype_public_keyword_state);
3304					return true;
3305				}
3306			} else if (['s', 'S'].indexOf(data) > -1) {
3307				var expected = [['y', 'Y'], ['s', 'S'], ['t', 'T'], ['e', 'E'], ['m', 'M']];
3308				var matched = expected.every(function(expected){
3309					data = buffer.char();
3310					return expected.indexOf(data) > -1;
3311				});
3312				if (matched) {
3313					tokenizer.setState(after_doctype_system_keyword_state);
3314					return true;
3315				}
3316			}
3317			buffer.unget(data);
3318			tokenizer._currentToken.forceQuirks = true;
3319
3320			if (data === InputStream.EOF) {
3321				tokenizer._parseError("eof-in-doctype");
3322				buffer.unget(data);
3323				tokenizer.setState(data_state);
3324				tokenizer._emitCurrentToken();
3325			} else {
3326				tokenizer._parseError("expected-space-or-right-bracket-in-doctype", {data: data});
3327				tokenizer.setState(bogus_doctype_state);
3328			}
3329		}
3330		return true;
3331	}
3332
3333	function after_doctype_public_keyword_state(buffer) {
3334		var data = buffer.char();
3335		if (data === InputStream.EOF) {
3336			tokenizer._parseError("eof-in-doctype");
3337			tokenizer._currentToken.forceQuirks = true;
3338			buffer.unget(data);
3339			tokenizer.setState(data_state);
3340			tokenizer._emitCurrentToken();
3341		} else if (isWhitespace(data)) {
3342			tokenizer.setState(before_doctype_public_identifier_state);
3343		} else if (data === "'" || data === '"') {
3344			tokenizer._parseError("unexpected-char-in-doctype");
3345			buffer.unget(data);
3346			tokenizer.setState(before_doctype_public_identifier_state);
3347		} else {
3348			buffer.unget(data);
3349			tokenizer.setState(before_doctype_public_identifier_state);
3350		}
3351		return true;
3352	}
3353
3354	function before_doctype_public_identifier_state(buffer) {
3355		var data = buffer.char();
3356		if (data === InputStream.EOF) {
3357			tokenizer._parseError("eof-in-doctype");
3358			tokenizer._currentToken.forceQuirks = true;

3359			buffer.unget(data);
3360			tokenizer.setState(data_state);
3361			tokenizer._emitCurrentToken();
3362		} else if (isWhitespace(data)) {
3363		} else if (data === '"') {
3364			tokenizer._currentToken.publicId = '';
3365			tokenizer.setState(doctype_public_identifier_double_quoted_state);
3366		} else if (data === "'") {
3367			tokenizer._currentToken.publicId = '';
3368			tokenizer.setState(doctype_public_identifier_single_quoted_state);
3369		} else if (data === '>') {
3370			tokenizer._parseError("unexpected-end-of-doctype");
3371			tokenizer._currentToken.forceQuirks = true;
3372			tokenizer.setState(data_state);
3373			tokenizer._emitCurrentToken();
3374		} else {
3375			tokenizer._parseError("unexpected-char-in-doctype");
3376			tokenizer._currentToken.forceQuirks = true;
3377			tokenizer.setState(bogus_doctype_state);
3378		}
3379		return true;
3380	}
3381
3382	function doctype_public_identifier_double_quoted_state(buffer) {
3383		var data = buffer.char();
3384		if (data === InputStream.EOF) {
3385			tokenizer._parseError("eof-in-doctype");
3386			tokenizer._currentToken.forceQuirks = true;
3387			buffer.unget(data);
3388			tokenizer.setState(data_state);
3389			tokenizer._emitCurrentToken();
3390		} else if (data === '"') {
3391			tokenizer.setState(after_doctype_public_identifier_state);
3392		} else if (data === '>') {
3393			tokenizer._parseError("unexpected-end-of-doctype");
3394			tokenizer._currentToken.forceQuirks = true;
3395			tokenizer.setState(data_state);
3396			tokenizer._emitCurrentToken();
3397		} else {
3398			tokenizer._currentToken.publicId += data;
3399		}
3400		return true;
3401	}
3402
3403	function doctype_public_identifier_single_quoted_state(buffer) {
3404		var data = buffer.char();
3405		if (data === InputStream.EOF) {
3406			tokenizer._parseError("eof-in-doctype");
3407			tokenizer._currentToken.forceQuirks = true;
3408			buffer.unget(data);
3409			tokenizer.setState(data_state);
3410			tokenizer._emitCurrentToken();
3411		} else if (data === "'") {
3412			tokenizer.setState(after_doctype_public_identifier_state);
3413		} else if (data === '>') {
3414			tokenizer._parseError("unexpected-end-of-doctype");
3415			tokenizer._currentToken.forceQuirks = true;
3416			tokenizer.setState(data_state);
3417			tokenizer._emitCurrentToken();
3418		} else {
3419			tokenizer._currentToken.publicId += data;
3420		}
3421		return true;
3422	}
3423
3424	function after_doctype_public_identifier_state(buffer) {
3425		var data = buffer.char();
3426		if (data === InputStream.EOF) {
3427			tokenizer._parseError("eof-in-doctype");
3428			tokenizer._currentToken.forceQuirks = true;
3429			tokenizer._emitCurrentToken();
3430			buffer.unget(data);
3431			tokenizer.setState(data_state);
3432		} else if (isWhitespace(data)) {
3433			tokenizer.setState(between_doctype_public_and_system_identifiers_state);
3434		} else if (data === '>') {
3435			tokenizer.setState(data_state);
3436			tokenizer._emitCurrentToken();
3437		} else if (data === '"') {
3438			tokenizer._parseError("unexpected-char-in-doctype");
3439			tokenizer._currentToken.systemId = '';
3440			tokenizer.setState(doctype_system_identifier_double_quoted_state);
3441		} else if (data === "'") {
3442			tokenizer._parseError("unexpected-char-in-doctype");
3443			tokenizer._currentToken.systemId = '';
3444			tokenizer.setState(doctype_system_identifier_single_quoted_state);
3445		} else {
3446			tokenizer._parseError("unexpected-char-in-doctype");
3447			tokenizer._currentToken.forceQuirks = true;
3448			tokenizer.setState(bogus_doctype_state);
3449		}
3450		return true;
3451	}
3452
3453	function between_doctype_public_and_system_identifiers_state(buffer) {
3454		var data = buffer.char();
3455		if (data === InputStream.EOF) {
3456			tokenizer._parseError("eof-in-doctype");
3457			tokenizer._currentToken.forceQuirks = true;
3458			tokenizer._emitCurrentToken();
3459			buffer.unget(data);
3460			tokenizer.setState(data_state);
3461		} else if (isWhitespace(data)) {
3462		} else if (data === '>') {
3463			tokenizer._emitCurrentToken();
3464			tokenizer.setState(data_state);
3465		} else if (data === '"') {
3466			tokenizer._currentToken.systemId = '';
3467			tokenizer.setState(doctype_system_identifier_double_quoted_state);
3468		} else if (data === "'") {
3469			tokenizer._currentToken.systemId = '';
3470			tokenizer.setState(doctype_system_identifier_single_quoted_state);
3471		} else {
3472			tokenizer._parseError("unexpected-char-in-doctype");
3473			tokenizer._currentToken.forceQuirks = true;
3474			tokenizer.setState(bogus_doctype_state);
3475		}
3476		return true;
3477	}
3478
3479	function after_doctype_system_keyword_state(buffer) {
3480		var data = buffer.char();
3481		if (data === InputStream.EOF) {
3482			tokenizer._parseError("eof-in-doctype");
3483			tokenizer._currentToken.forceQuirks = true;
3484			tokenizer._emitCurrentToken();

3485			buffer.unget(data);
3486			tokenizer.setState(data_state);
3487		} else if (isWhitespace(data)) {
3488			tokenizer.setState(before_doctype_system_identifier_state);
3489		} else if (data === "'" || data === '"') {
3490			tokenizer._parseError("unexpected-char-in-doctype");
3491			buffer.unget(data);
3492			tokenizer.setState(before_doctype_system_identifier_state);
3493		} else {
3494			buffer.unget(data);
3495			tokenizer.setState(before_doctype_system_identifier_state);
3496		}
3497		return true;
3498	}
3499
3500	function before_doctype_system_identifier_state(buffer) {
3501		var data = buffer.char();
3502		if (data === InputStream.EOF) {
3503			tokenizer._parseError("eof-in-doctype");
3504			tokenizer._currentToken.forceQuirks = true;
3505			tokenizer._emitCurrentToken();
3506			buffer.unget(data);
3507			tokenizer.setState(data_state);
3508		} else if (isWhitespace(data)) {
3509		} else if (data === '"') {
3510			tokenizer._currentToken.systemId = '';
3511			tokenizer.setState(doctype_system_identifier_double_quoted_state);
3512		} else if (data === "'") {
3513			tokenizer._currentToken.systemId = '';
3514			tokenizer.setState(doctype_system_identifier_single_quoted_state);
3515		} else if (data === '>') {
3516			tokenizer._parseError("unexpected-end-of-doctype");
3517			tokenizer._currentToken.forceQuirks = true;
3518			tokenizer._emitCurrentToken();
3519			tokenizer.setState(data_state);
3520		} else {
3521			tokenizer._parseError("unexpected-char-in-doctype");
3522			tokenizer._currentToken.forceQuirks = true;
3523			tokenizer.setState(bogus_doctype_state);
3524		}
3525		return true;
3526	}
3527
3528	function doctype_system_identifier_double_quoted_state(buffer) {
3529		var data = buffer.char();
3530		if (data === InputStream.EOF) {
3531			tokenizer._parseError("eof-in-doctype");
3532			tokenizer._currentToken.forceQuirks = true;
3533			tokenizer._emitCurrentToken();
3534			buffer.unget(data);
3535			tokenizer.setState(data_state);
3536		} else if (data === '"') {
3537			tokenizer.setState(after_doctype_system_identifier_state);
3538		} else if (data === '>') {
3539			tokenizer._parseError("unexpected-end-of-doctype");
3540			tokenizer._currentToken.forceQuirks = true;
3541			tokenizer._emitCurrentToken();
3542			tokenizer.setState(data_state);
3543		} else {
3544			tokenizer._currentToken.systemId += data;
3545		}
3546		return true;
3547	}
3548
3549	function doctype_system_identifier_single_quoted_state(buffer) {
3550		var data = buffer.char();
3551		if (data === InputStream.EOF) {
3552			tokenizer._parseError("eof-in-doctype");
3553			tokenizer._currentToken.forceQuirks = true;
3554			tokenizer._emitCurrentToken();
3555			buffer.unget(data);
3556			tokenizer.setState(data_state);
3557		} else if (data === "'") {
3558			tokenizer.setState(after_doctype_system_identifier_state);
3559		} else if (data === '>') {
3560			tokenizer._parseError("unexpected-end-of-doctype");
3561			tokenizer._currentToken.forceQuirks = true;
3562			tokenizer._emitCurrentToken();
3563			tokenizer.setState(data_state);
3564		} else {
3565			tokenizer._currentToken.systemId += data;
3566		}
3567		return true;
3568	}
3569
3570	function after_doctype_system_identifier_state(buffer) {
3571		var data = buffer.char();
3572		if (data === InputStream.EOF) {
3573			tokenizer._parseError("eof-in-doctype");
3574			tokenizer._currentToken.forceQuirks = true;
3575			tokenizer._emitCurrentToken();
3576			buffer.unget(data);
3577			tokenizer.setState(data_state);
3578		} else if (isWhitespace(data)) {
3579		} else if (data === '>') {
3580			tokenizer._emitCurrentToken();
3581			tokenizer.setState(data_state);
3582		} else {
3583			tokenizer._parseError("unexpected-char-in-doctype");
3584			tokenizer.setState(bogus_doctype_state);
3585		}
3586		return true;
3587	}
3588
3589	function bogus_doctype_state(buffer) {
3590		var data = buffer.char();
3591		if (data === InputStream.EOF) {
3592			buffer.unget(data);
3593			tokenizer._emitCurrentToken();
3594			tokenizer.setState(data_state);
3595		} else if (data === '>') {
3596			tokenizer._emitCurrentToken();
3597			tokenizer.setState(data_state);
3598		}
3599		return true;
3600	}
3601};
3602
3603Object.defineProperty(Tokenizer.prototype, 'lineNumber', {
3604	get: function() {
3605		return this._inputStream.location().line;
3606	}
3607});
3608
3609Object.defineProperty(Tokenizer.prototype, 'columnNumber', {
3610	get: function() {
3611		return this._inputStream.location().column;
3612	}
3613});
3614
3615exports.Tokenizer = Tokenizer;
3616
3617},
3618{"./EntityParser":2,"./InputStream":3}],
36196:[function(_dereq_,module,exports){
3620var assert = _dereq_('assert');
3621
3622var messages = _dereq_('./messages.json');
3623var constants = _dereq_('./constants');
3624
3625var EventEmitter = _dereq_('events').EventEmitter;
3626
3627var Tokenizer = _dereq_('./Tokenizer').Tokenizer;
3628var ElementStack = _dereq_('./ElementStack').ElementStack;
3629var StackItem = _dereq_('./StackItem').StackItem;
3630
3631var Marker = {};
3632
3633function isWhitespace(ch) {
3634	return ch === " " || ch === "\n" || ch === "\t" || ch === "\r" || ch === "\f";
3635}
3636
3637function isWhitespaceOrReplacementCharacter(ch) {
3638	return isWhitespace(ch) || ch === '\uFFFD';
3639}
3640
3641function isAllWhitespace(characters) {
3642	for (var i = 0; i < characters.length; i++) {
3643		var ch = characters[i];
3644		if (!isWhitespace(ch))
3645			return false;

3646	}
3647	return true;
3648}
3649
3650function isAllWhitespaceOrReplacementCharacters(characters) {
3651	for (var i = 0; i < characters.length; i++) {
3652		var ch = characters[i];
3653		if (!isWhitespaceOrReplacementCharacter(ch))
3654			return false;
3655	}
3656	return true;
3657}
3658
3659function getAttribute(node, name) {
3660	for (var i = 0; i < node.attributes.length; i++) {
3661		var attribute = node.attributes[i];
3662		if (attribute.nodeName === name) {
3663			return attribute;
3664		}
3665	}
3666	return null;
3667}
3668
3669function CharacterBuffer(characters) {
3670	this.characters = characters;
3671	this.current = 0;
3672	this.end = this.characters.length;
3673}
3674
3675CharacterBuffer.prototype.skipAtMostOneLeadingNewline = function() {
3676	if (this.characters[this.current] === '\n')
3677		this.current++;
3678};
3679
3680CharacterBuffer.prototype.skipLeadingWhitespace = function() {
3681	while (isWhitespace(this.characters[this.current])) {
3682		if (++this.current == this.end)
3683			return;
3684	}
3685};
3686
3687CharacterBuffer.prototype.skipLeadingNonWhitespace = function() {
3688	while (!isWhitespace(this.characters[this.current])) {
3689		if (++this.current == this.end)
3690			return;
3691	}
3692};
3693
3694CharacterBuffer.prototype.takeRemaining = function() {
3695	return this.characters.substring(this.current);
3696};
3697
3698CharacterBuffer.prototype.takeLeadingWhitespace = function() {
3699	var start = this.current;
3700	this.skipLeadingWhitespace();
3701	if (start === this.current)
3702		return "";
3703	return this.characters.substring(start, this.current - start);
3704};
3705
3706Object.defineProperty(CharacterBuffer.prototype, 'length', {
3707	get: function(){
3708		return this.end - this.current;
3709	}
3710});
3711function TreeBuilder() {
3712	this.tokenizer = null;
3713	this.errorHandler = null;
3714	this.scriptingEnabled = false;
3715	this.document = null;
3716	this.head = null;
3717	this.form = null;
3718	this.openElements = new ElementStack();
3719	this.activeFormattingElements = [];
3720	this.insertionMode = null;
3721	this.insertionModeName = "";
3722	this.originalInsertionMode = "";
3723	this.inQuirksMode = false; // TODO quirks mode
3724	this.compatMode = "no quirks";
3725	this.framesetOk = true;
3726	this.redirectAttachToFosterParent = false;
3727	this.selfClosingFlagAcknowledged = false;
3728	this.context = "";
3729	this.pendingTableCharacters = [];
3730	this.shouldSkipLeadingNewline = false;
3731
3732	var tree = this;
3733	var modes = this.insertionModes = {};
3734	modes.base = {
3735		end_tag_handlers: {"-default": 'endTagOther'},
3736		start_tag_handlers: {"-default": 'startTagOther'},
3737		processEOF: function() {
3738			tree.generateImpliedEndTags();
3739			if (tree.openElements.length > 2) {
3740				tree.parseError('expected-closing-tag-but-got-eof');
3741			} else if (tree.openElements.length == 2 &&
3742				tree.openElements.item(1).localName != 'body') {
3743				tree.parseError('expected-closing-tag-but-got-eof');
3744			} else if (tree.context && tree.openElements.length > 1) {
3745			}
3746		},
3747		processComment: function(data) {
3748			tree.insertComment(data, tree.currentStackItem().node);
3749		},
3750		processDoctype: function(name, publicId, systemId, forceQuirks) {
3751			tree.parseError('unexpected-doctype');
3752		},
3753		processStartTag: function(name, attributes, selfClosing) {
3754			if (this[this.start_tag_handlers[name]]) {
3755				this[this.start_tag_handlers[name]](name, attributes, selfClosing);
3756			} else if (this[this.start_tag_handlers["-default"]]) {
3757				this[this.start_tag_handlers["-default"]](name, attributes, selfClosing);
3758			} else {
3759				throw(new Error("No handler found for "+name));
3760			}
3761		},
3762		processEndTag: function(name) {
3763			if (this[this.end_tag_handlers[name]]) {
3764				this[this.end_tag_handlers[name]](name);
3765			} else if (this[this.end_tag_handlers["-default"]]) {
3766				this[this.end_tag_handlers["-default"]](name);
3767			} else {
3768				throw(new Error("No handler found for "+name));
3769			}
3770		},
3771		startTagHtml: function(name, attributes) {
3772			modes.inBody.startTagHtml(name, attributes);
3773		}
3774	};
3775
3776	modes.initial = Object.create(modes.base);
3777
3778	modes.initial.processEOF = function() {
3779		tree.parseError("expected-doctype-but-got-eof");
3780		this.anythingElse();
3781		tree.insertionMode.processEOF();
3782	};
3783
3784	modes.initial.processComment = function(data) {
3785		tree.insertComment(data, tree.document);
3786	};
3787
3788	modes.initial.processDoctype = function(name, publicId, systemId, forceQuirks) {
3789		tree.insertDoctype(name || '', publicId || '', systemId || '');
3790
3791		if (forceQuirks || name != 'html' || (publicId != null && ([
3792					"+//silmaril//dtd html pro v0r11 19970101//",
3793					"-//advasoft ltd//dtd html 3.0 aswedit + extensions//",
3794					"-//as//dtd html 3.0 aswedit + extensions//",
3795					"-//ietf//dtd html 2.0 level 1//",
3796					"-//ietf//dtd html 2.0 level 2//",
3797					"-//ietf//dtd html 2.0 strict level 1//",
3798					"-//ietf//dtd html 2.0 strict level 2//",
3799					"-//ietf//dtd html 2.0 strict//",
3800					"-//ietf//dtd html 2.0//",
3801					"-//ietf//dtd html 2.1e//",
3802					"-//ietf//dtd html 3.0//",
3803					"-//ietf//dtd html 3.0//",
3804					"-//ietf//dtd html 3.2 final//",
3805					"-//ietf//dtd html 3.2//",
3806					"-//ietf//dtd html 3//",
3807					"-//ietf//dtd html level 0//",
3808					"-//ietf//dtd html level 0//",
3809					"-//ietf//dtd html level 1//",
3810					"-//ietf//dtd html level 1//",
3811					"-//ietf//dtd html level 2//",
3812					"-//ietf//dtd html level 2//",
3813					"-//ietf//dtd html level 3//",
3814					"-//ietf//dtd html level 3//",
3815					"-//ietf//dtd html strict level 0//",
3816					"-//ietf//dtd html strict level 0//",
3817					"-//ietf//dtd html strict level 1//",
3818					"-//ietf//dtd html strict level 1//",
3819					"-//ietf//dtd html strict level 2//",
3820					"-//ietf//dtd html strict level 2//",
3821					"-//ietf//dtd html strict level 3//",
3822					"-//ietf//dtd html strict level 3//",
3823					"-//ietf//dtd html strict//",
3824					"-//ietf//dtd html strict//",
3825					"-//ietf//dtd html strict//",
3826					"-//ietf//dtd html//",
3827					"-//ietf//dtd html//",
3828					"-//ietf//dtd html//",
3829					"-//metrius//dtd metrius presentational//",
3830					"-//microsoft//dtd internet explorer 2.0 html strict//",
3831					"-//microsoft//dtd internet explorer 2.0 html//",
3832					"-//microsoft//dtd internet explorer 2.0 tables//",
3833					"-//microsoft//dtd internet explorer 3.0 html strict//",
3834					"-//microsoft//dtd internet explorer 3.0 html//",
3835					"-//microsoft//dtd internet explorer 3.0 tables//",
3836					"-//netscape comm. corp.//dtd html//",
3837					"-//netscape comm. corp.//dtd strict html//",
3838					"-//o'reilly and associates//dtd html 2.0//",
3839					"-//o'reilly and associates//dtd html extended 1.0//",
3840					"-//spyglass//dtd html 2.0 extended//",
3841					"-//sq//dtd html 2.0 hotmetal + extensions//",
3842					"-//sun microsystems corp.//dtd hotjava html//",
3843					"-//sun microsystems corp.//dtd hotjava strict html//",
3844					"-//w3c//dtd html 3 1995-03-24//",
3845					"-//w3c//dtd html 3.2 draft//",
3846					"-//w3c//dtd html 3.2 final//",
3847					"-//w3c//dtd html 3.2//",
3848					"-//w3c//dtd html 3.2s draft//",
3849					"-//w3c//dtd html 4.0 frameset//",
3850					"-//w3c//dtd html 4.0 transitional//",
3851					"-//w3c//dtd html experimental 19960712//",
3852					"-//w3c//dtd html experimental 970421//",
3853					"-//w3c//dtd w3 html//",
3854					"-//w3o//dtd w3 html 3.0//",
3855					"-//webtechs//dtd mozilla html 2.0//",
3856					"-//webtechs//dtd mozilla html//",
3857					"html"
3858				].some(publicIdStartsWith)
3859				|| [
3860					"-//w3o//dtd w3 html strict 3.0//en//",
3861					"-/w3c/dtd html 4.0 transitional/en",
3862					"html"
3863				].indexOf(publicId.toLowerCase()) > -1
3864				|| (systemId == null && [
3865					"-//w3c//dtd html 4.01 transitional//",
3866					"-//w3c//dtd html 4.01 frameset//"
3867				].some(publicIdStartsWith)))
3868			)
3869			|| (systemId != null && (systemId.toLowerCase() == "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"))
3870		) {
3871			tree.compatMode = "quirks";
3872			tree.parseError("quirky-doctype");
3873		} else if (publicId != null && ([
3874				"-//w3c//dtd xhtml 1.0 transitional//",
3875				"-//w3c//dtd xhtml 1.0 frameset//"
3876			].some(publicIdStartsWith)
3877			|| (systemId != null && [
3878				"-//w3c//dtd html 4.01 transitional//",
3879				"-//w3c//dtd html 4.01 frameset//"
3880			].indexOf(publicId.toLowerCase()) > -1))
3881		) {
3882			tree.compatMode = "limited quirks";
3883			tree.parseError("almost-standards-doctype");
3884		} else {
3885			if ((publicId == "-//W3C//DTD HTML 4.0//EN" && (systemId == null || systemId == "http://www.w3.org/TR/REC-html40/strict.dtd"))
3886				|| (publicId == "-//W3C//DTD HTML 4.01//EN" && (systemId == null || systemId == "http://www.w3.org/TR/html4/strict.dtd"))
3887				|| (publicId == "-//W3C//DTD XHTML 1.0 Strict//EN" && (systemId == "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"))
3888				|| (publicId == "-//W3C//DTD XHTML 1.1//EN" && (systemId == "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"))
3889			) {
3890			} else if (!((systemId == null || systemId == "about:legacy-compat") && publicId == null)) {
3891				tree.parseError("unknown-doctype");
3892			}
3893		}
3894		tree.setInsertionMode('beforeHTML');
3895		function publicIdStartsWith(string) {
3896			return publicId.toLowerCase().indexOf(string) === 0;
3897		}
3898	};
3899
3900	modes.initial.processCharacters = function(buffer) {
3901		buffer.skipLeadingWhitespace();
3902		if (!buffer.length)
3903			return;
3904		tree.parseError('expected-doctype-but-got-chars');
3905		this.anythingElse();
3906		tree.insertionMode.processCharacters(buffer);
3907	};
3908
3909	modes.initial.processStartTag = function(name, attributes, selfClosing) {
3910		tree.parseError('expected-doctype-but-got-start-tag', {name: name});
3911		this.anythingElse();
3912		tree.insertionMode.processStartTag(name, attributes, selfClosing);
3913	};
3914
3915	modes.initial.processEndTag = function(name) {
3916		tree.parseError('expected-doctype-but-got-end-tag', {name: name});
3917		this.anythingElse();
3918		tree.insertionMode.processEndTag(name);
3919	};
3920
3921	modes.initial.anythingElse = function() {
3922		tree.compatMode = 'quirks';
3923		tree.setInsertionMode('beforeHTML');
3924	};
3925
3926	modes.beforeHTML = Object.create(modes.base);
3927
3928	modes.beforeHTML.start_tag_handlers = {
3929		html: 'startTagHtml',
3930		'-default': 'startTagOther'
3931	};
3932
3933	modes.beforeHTML.processEOF = function() {
3934		this.anythingElse();
3935		tree.insertionMode.processEOF();
3936	};
3937
3938	modes.beforeHTML.processComment = function(data) {
3939		tree.insertComment(data, tree.document);
3940	};
3941
3942	modes.beforeHTML.processCharacters = function(buffer) {
3943		buffer.skipLeadingWhitespace();
3944		if (!buffer.length)
3945			return;
3946		this.anythingElse();
3947		tree.insertionMode.processCharacters(buffer);
3948	};
3949
3950	modes.beforeHTML.startTagHtml = function(name, attributes, selfClosing) {
3951		tree.insertHtmlElement(attributes);
3952		tree.setInsertionMode('beforeHead');
3953	};
3954
3955	modes.beforeHTML.startTagOther = function(name, attributes, selfClosing) {
3956		this.anythingElse();
3957		tree.insertionMode.processStartTag(name, attributes, selfClosing);
3958	};
3959
3960	modes.beforeHTML.processEndTag = function(name) {
3961		this.anythingElse();
3962		tree.insertionMode.processEndTag(name);
3963	};
3964
3965	modes.beforeHTML.anythingElse = function() {
3966		tree.insertHtmlElement();
3967		tree.setInsertionMode('beforeHead');
3968	};
3969
3970	modes.afterAfterBody = Object.create(modes.base);
3971
3972	modes.afterAfterBody.start_tag_handlers = {
3973		html: 'startTagHtml',
3974		'-default': 'startTagOther'
3975	};
3976
3977	modes.afterAfterBody.processComment = function(data) {
3978		tree.insertComment(data, tree.document);
3979	};
3980
3981	modes.afterAfterBody.processDoctype = function(data) {
3982		modes.inBody.processDoctype(data);
3983	};
3984
3985	modes.afterAfterBody.startTagHtml = function(data, attributes) {
3986		modes.inBody.startTagHtml(data, attributes);
3987	};
3988
3989	modes.afterAfterBody.startTagOther = function(name, attributes, selfClosing) {
3990		tree.parseError('unexpected-start-tag', {name: name});
3991		tree.setInsertionMode('inBody');
3992		tree.insertionMode.processStartTag(name, attributes, selfClosing);
3993	};
3994
3995	modes.afterAfterBody.endTagOther = function(name) {
3996		tree.parseError('unexpected-end-tag', {name: name});
3997		tree.setInsertionMode('inBody');
3998		tree.insertionMode.processEndTag(name);
3999	};
4000
4001	modes.afterAfterBody.processCharacters = function(data) {
4002		if (!isAllWhitespace(data.characters)) {
4003			tree.parseError('unexpected-char-after-body');
4004			tree.setInsertionMode('inBody');
4005			return tree.insertionMode.processCharacters(data);
4006		}
4007		modes.inBody.processCharacters(data);
4008	};
4009
4010	modes.afterBody = Object.create(modes.base);
4011
4012	modes.afterBody.end_tag_handlers = {
4013		html: 'endTagHtml',
4014		'-default': 'endTagOther'
4015	};
4016
4017	modes.afterBody.processComment = function(data) {
4018		tree.insertComment(data, tree.openElements.rootNode);
4019	};
4020
4021	modes.afterBody.processCharacters = function(data) {
4022		if (!isAllWhitespace(data.characters)) {
4023			tree.parseError('unexpected-char-after-body');
4024			tree.setInsertionMode('inBody');
4025			return tree.insertionMode.processCharacters(data);
4026		}
4027		modes.inBody.processCharacters(data);
4028	};
4029
4030	modes.afterBody.processStartTag = function(name, attributes, selfClosing) {
4031		tree.parseError('unexpected-start-tag-after-body', {name: name});
4032		tree.setInsertionMode('inBody');
4033		tree.insertionMode.processStartTag(name, attributes, selfClosing);
4034	};
4035
4036	modes.afterBody.endTagHtml = function(name) {
4037		if (tree.context) {
4038			tree.parseError('end-html-in-innerhtml');
4039		} else {
4040			tree.setInsertionMode('afterAfterBody');
4041		}
4042	};
4043
4044	modes.afterBody.endTagOther = function(name) {
4045		tree.parseError('unexpected-end-tag-after-body', {name: name});
4046		tree.setInsertionMode('inBody');
4047		tree.insertionMode.processEndTag(name);
4048	};
4049
4050	modes.afterFrameset = Object.create(modes.base);
4051
4052	modes.afterFrameset.start_tag_handlers = {
4053		html: 'startTagHtml',
4054		noframes: 'startTagNoframes',
4055		'-default': 'startTagOther'
4056	};
4057
4058	modes.afterFrameset.end_tag_handlers = {
4059		html: 'endTagHtml',
4060		'-default': 'endTagOther'
4061	};
4062
4063	modes.afterFrameset.processCharacters = function(buffer) {
4064		var characters = buffer.takeRemaining();
4065		var whitespace = "";
4066		for (var i = 0; i < characters.length; i++) {
4067			var ch = characters[i];
4068			if (isWhitespace(ch))
4069				whitespace += ch;
4070		}
4071		if (whitespace) {
4072			tree.insertText(whitespace);
4073		}
4074		if (whitespace.length < characters.length)
4075			tree.parseError('expected-eof-but-got-char');
4076	};
4077
4078	modes.afterFrameset.startTagNoframes = function(name, attributes) {
4079		modes.inHead.processStartTag(name, attributes);
4080	};
4081
4082	modes.afterFrameset.startTagOther = function(name, attributes) {
4083		tree.parseError("unexpected-start-tag-after-frameset", {name: name});
4084	};
4085
4086	modes.afterFrameset.endTagHtml = function(name) {
4087		tree.setInsertionMode('afterAfterFrameset');
4088	};
4089
4090	modes.afterFrameset.endTagOther = function(name) {
4091		tree.parseError("unexpected-end-tag-after-frameset", {name: name});
4092	};
4093
4094	modes.beforeHead = Object.create(modes.base);
4095
4096	modes.beforeHead.start_tag_handlers = {
4097		html: 'startTagHtml',
4098		head: 'startTagHead',
4099		'-default': 'startTagOther'
4100	};
4101
4102	modes.beforeHead.end_tag_handlers = {
4103		html: 'endTagImplyHead',
4104		head: 'endTagImplyHead',
4105		body: 'endTagImplyHead',
4106		br: 'endTagImplyHead',
4107		'-default': 'endTagOther'
4108	};
4109
4110	modes.beforeHead.processEOF = function() {
4111		this.startTagHead('head', []);
4112		tree.insertionMode.processEOF();
4113	};
4114
4115	modes.beforeHead.processCharacters = function(buffer) {
4116		buffer.skipLeadingWhitespace();
4117		if (!buffer.length)
4118			return;
4119		this.startTagHead('head', []);
4120		tree.insertionMode.processCharacters(buffer);
4121	};
4122
4123	modes.beforeHead.startTagHead = function(name, attributes) {
4124		tree.insertHeadElement(attributes);
4125		tree.setInsertionMode('inHead');
4126	};
4127
4128	modes.beforeHead.startTagOther = function(name, attributes, selfClosing) {
4129		this.startTagHead('head', []);
4130		tree.insertionMode.processStartTag(name, attributes, selfClosing);
4131	};
4132
4133	modes.beforeHead.endTagImplyHead = function(name) {
4134		this.startTagHead('head', []);
4135		tree.insertionMode.processEndTag(name);
4136	};
4137
4138	modes.beforeHead.endTagOther = function(name) {
4139		tree.parseError('end-tag-after-implied-root', {name: name});
4140	};
4141
4142	modes.inHead = Object.create(modes.base);
4143
4144	modes.inHead.start_tag_handlers = {
4145		html: 'startTagHtml',
4146		head: 'startTagHead',
4147		title: 'startTagTitle',
4148		script: 'startTagScript',
4149		style: 'startTagNoFramesStyle',
4150		noscript: 'startTagNoScript',
4151		noframes: 'startTagNoFramesStyle',
4152		base: 'startTagBaseBasefontBgsoundLink',
4153		basefont: 'startTagBaseBasefontBgsoundLink',
4154		bgsound: 'startTagBaseBasefontBgsoundLink',
4155		link: 'startTagBaseBasefontBgsoundLink',
4156		meta: 'startTagMeta',
4157		"-default": 'startTagOther'
4158	};
4159
4160	modes.inHead.end_tag_handlers = {
4161		head: 'endTagHead',
4162		html: 'endTagHtmlBodyBr',
4163		body: 'endTagHtmlBodyBr',
4164		br: 'endTagHtmlBodyBr',

4165		"-default": 'endTagOther'
4166	};
4167
4168	modes.inHead.processEOF = function() {
4169		var name = tree.currentStackItem().localName;
4170		if (['title', 'style', 'script'].indexOf(name) != -1) {
4171			tree.parseError("expected-named-closing-tag-but-got-eof", {name: name});
4172			tree.popElement();
4173		}
4174
4175		this.anythingElse();
4176
4177		tree.insertionMode.processEOF();
4178	};
4179
4180	modes.inHead.processCharacters = function(buffer) {
4181		var leadingWhitespace = buffer.takeLeadingWhitespace();
4182		if (leadingWhitespace)
4183			tree.insertText(leadingWhitespace);
4184		if (!buffer.length)
4185			return;
4186		this.anythingElse();
4187		tree.insertionMode.processCharacters(buffer);
4188	};
4189
4190	modes.inHead.startTagHtml = function(name, attributes) {
4191		modes.inBody.processStartTag(name, attributes);
4192	};
4193
4194	modes.inHead.startTagHead = function(name, attributes) {
4195		tree.parseError('two-heads-are-not-better-than-one');
4196	};
4197
4198	modes.inHead.startTagTitle = function(name, attributes) {
4199		tree.processGenericRCDATAStartTag(name, attributes);
4200	};
4201
4202	modes.inHead.startTagNoScript = function(name, attributes) {
4203		if (tree.scriptingEnabled)
4204			return tree.processGenericRawTextStartTag(name, attributes);
4205		tree.insertElement(name, attributes);
4206		tree.setInsertionMode('inHeadNoscript');
4207	};
4208
4209	modes.inHead.startTagNoFramesStyle = function(name, attributes) {
4210		tree.processGenericRawTextStartTag(name, attributes);
4211	};
4212
4213	modes.inHead.startTagScript = function(name, attributes) {
4214		tree.insertElement(name, attributes);
4215		tree.tokenizer.setState(Tokenizer.SCRIPT_DATA);
4216		tree.originalInsertionMode = tree.insertionModeName;
4217		tree.setInsertionMode('text');
4218	};
4219
4220	modes.inHead.startTagBaseBasefontBgsoundLink = function(name, attributes) {
4221		tree.insertSelfClosingElement(name, attributes);
4222	};
4223
4224	modes.inHead.startTagMeta = function(name, attributes) {
4225		tree.insertSelfClosingElement(name, attributes);
4226	};
4227
4228	modes.inHead.startTagOther = function(name, attributes, selfClosing) {
4229		this.anythingElse();
4230		tree.insertionMode.processStartTag(name, attributes, selfClosing);
4231	};
4232
4233	modes.inHead.endTagHead = function(name) {
4234		if (tree.openElements.item(tree.openElements.length - 1).localName == 'head') {
4235			tree.openElements.pop();
4236		} else {
4237			tree.parseError('unexpected-end-tag', {name: 'head'});
4238		}
4239		tree.setInsertionMode('afterHead');
4240	};
4241
4242	modes.inHead.endTagHtmlBodyBr = function(name) {
4243		this.anythingElse();
4244		tree.insertionMode.processEndTag(name);
4245	};
4246
4247	modes.inHead.endTagOther = function(name) {
4248		tree.parseError('unexpected-end-tag', {name: name});
4249	};
4250
4251	modes.inHead.anythingElse = function() {
4252		this.endTagHead('head');
4253	};
4254
4255	modes.afterHead = Object.create(modes.base);
4256
4257	modes.afterHead.start_tag_handlers = {
4258		html: 'startTagHtml',
4259		head: 'startTagHead',
4260		body: 'startTagBody',
4261		frameset: 'startTagFrameset',
4262		base: 'startTagFromHead',
4263		link: 'startTagFromHead',
4264		meta: 'startTagFromHead',
4265		script: 'startTagFromHead',
4266		style: 'startTagFromHead',
4267		title: 'startTagFromHead',
4268		"-default": 'startTagOther'
4269	};
4270
4271	modes.afterHead.end_tag_handlers = {
4272		body: 'endTagBodyHtmlBr',
4273		html: 'endTagBodyHtmlBr',
4274		br: 'endTagBodyHtmlBr',
4275		"-default": 'endTagOther'
4276	};
4277
4278	modes.afterHead.processEOF = function() {
4279		this.anythingElse();
4280		tree.insertionMode.processEOF();
4281	};
4282
4283	modes.afterHead.processCharacters = function(buffer) {
4284		var leadingWhitespace = buffer.takeLeadingWhitespace();
4285		if (leadingWhitespace)
4286			tree.insertText(leadingWhitespace);
4287		if (!buffer.length)
4288			return;
4289		this.anythingElse();
4290		tree.insertionMode.processCharacters(buffer);
4291	};
4292
4293	modes.afterHead.startTagHtml = function(name, attributes) {
4294		modes.inBody.processStartTag(name, attributes);
4295	};
4296
4297	modes.afterHead.startTagBody = function(name, attributes) {
4298		tree.framesetOk = false;
4299		tree.insertBodyElement(attributes);
4300		tree.setInsertionMode('inBody');
4301	};
4302
4303	modes.afterHead.startTagFrameset = function(name, attributes) {
4304		tree.insertElement(name, attributes);
4305		tree.setInsertionMode('inFrameset');
4306	};
4307
4308	modes.afterHead.startTagFromHead = function(name, attributes, selfClosing) {
4309		tree.parseError("unexpected-start-tag-out-of-my-head", {name: name});
4310		tree.openElements.push(tree.head);
4311		modes.inHead.processStartTag(name, attributes, selfClosing);
4312		tree.openElements.remove(tree.head);
4313	};
4314
4315	modes.afterHead.startTagHead = function(name, attributes, selfClosing) {
4316		tree.parseError('unexpected-start-tag', {name: name});
4317	};
4318
4319	modes.afterHead.startTagOther = function(name, attributes, selfClosing) {
4320		this.anythingElse();
4321		tree.insertionMode.processStartTag(name, attributes, selfClosing);
4322	};
4323
4324	modes.afterHead.endTagBodyHtmlBr = function(name) {
4325		this.anythingElse();
4326		tree.insertionMode.processEndTag(name);
4327	};
4328
4329	modes.afterHead.endTagOther = function(name) {
4330		tree.parseError('unexpected-end-tag', {name: name});
4331	};
4332
4333	modes.afterHead.anythingElse = function() {
4334		tree.insertBodyElement([]);
4335		tree.setInsertionMode('inBody');
4336		tree.framesetOk = true;
4337	}
4338
4339	modes.inBody = Object.create(modes.base);
4340
4341	modes.inBody.start_tag_handlers = {
4342		html: 'startTagHtml',
4343		head: 'startTagMisplaced',
4344		base: 'startTagProcessInHead',
4345		basefont: 'startTagProcessInHead',
4346		bgsound: 'startTagProcessInHead',
4347		link: 'startTagProcessInHead',
4348		meta: 'startTagProcessInHead',
4349		noframes: 'startTagProcessInHead',
4350		script: 'startTagProcessInHead',
4351		style: 'startTagProcessInHead',
4352		title: 'startTagProcessInHead',
4353		body: 'startTagBody',
4354		form: 'startTagForm',
4355		plaintext: 'startTagPlaintext',
4356		a: 'startTagA',
4357		button: 'startTagButton',
4358		xmp: 'startTagXmp',
4359		table: 'startTagTable',
4360		hr: 'startTagHr',
4361		image: 'startTagImage',
4362		input: 'startTagInput',
4363		textarea: 'startTagTextarea',
4364		select: 'startTagSelect',
4365		isindex: 'startTagIsindex',
4366		applet:	'startTagAppletMarqueeObject',
4367		marquee:	'startTagAppletMarqueeObject',
4368		object:	'startTagAppletMarqueeObject',
4369		li: 'startTagListItem',
4370		dd: 'startTagListItem',
4371		dt: 'startTagListItem',
4372		address: 'startTagCloseP',
4373		article: 'startTagCloseP',
4374		aside: 'startTagCloseP',
4375		blockquote: 'startTagCloseP',
4376		center: 'startTagCloseP',
4377		details: 'startTagCloseP',
4378		dir: 'startTagCloseP',
4379		div: 'startTagCloseP',
4380		dl: 'startTagCloseP',
4381		fieldset: 'startTagCloseP',
4382		figcaption: 'startTagCloseP',
4383		figure: 'startTagCloseP',
4384		footer: 'startTagCloseP',

4385		header: 'startTagCloseP',
4386		hgroup: 'startTagCloseP',
4387		main: 'startTagCloseP',
4388		menu: 'startTagCloseP',
4389		nav: 'startTagCloseP',
4390		ol: 'startTagCloseP',
4391		p: 'startTagCloseP',
4392		section: 'startTagCloseP',
4393		summary: 'startTagCloseP',
4394		ul: 'startTagCloseP',
4395		listing: 'startTagPreListing',
4396		pre: 'startTagPreListing',
4397		b: 'startTagFormatting',
4398		big: 'startTagFormatting',
4399		code: 'startTagFormatting',
4400		em: 'startTagFormatting',
4401		font: 'startTagFormatting',
4402		i: 'startTagFormatting',
4403		s: 'startTagFormatting',
4404		small: 'startTagFormatting',
4405		strike: 'startTagFormatting',
4406		strong: 'startTagFormatting',
4407		tt: 'startTagFormatting',
4408		u: 'startTagFormatting',
4409		nobr: 'startTagNobr',
4410		area: 'startTagVoidFormatting',
4411		br: 'startTagVoidFormatting',
4412		embed: 'startTagVoidFormatting',
4413		img: 'startTagVoidFormatting',
4414		keygen: 'startTagVoidFormatting',
4415		wbr: 'startTagVoidFormatting',
4416		param: 'startTagParamSourceTrack',
4417		source: 'startTagParamSourceTrack',
4418		track: 'startTagParamSourceTrack',
4419		iframe: 'startTagIFrame',
4420		noembed: 'startTagRawText',
4421		noscript: 'startTagRawText',
4422		h1: 'startTagHeading',
4423		h2: 'startTagHeading',
4424		h3: 'startTagHeading',
4425		h4: 'startTagHeading',
4426		h5: 'startTagHeading',
4427		h6: 'startTagHeading',
4428		caption: 'startTagMisplaced',
4429		col: 'startTagMisplaced',
4430		colgroup: 'startTagMisplaced',
4431		frame: 'startTagMisplaced',
4432		frameset: 'startTagFrameset',
4433		tbody: 'startTagMisplaced',
4434		td: 'startTagMisplaced',
4435		tfoot: 'startTagMisplaced',
4436		th: 'startTagMisplaced',
4437		thead: 'startTagMisplaced',
4438		tr: 'startTagMisplaced',
4439		option: 'startTagOptionOptgroup',
4440		optgroup: 'startTagOptionOptgroup',
4441		math: 'startTagMath',
4442		svg: 'startTagSVG',
4443		rt: 'startTagRpRt',
4444		rp: 'startTagRpRt',
4445		"-default": 'startTagOther'
4446	};
4447
4448	modes.inBody.end_tag_handlers = {
4449		p: 'endTagP',
4450		body: 'endTagBody',
4451		html: 'endTagHtml',
4452		address: 'endTagBlock',
4453		article: 'endTagBlock',
4454		aside: 'endTagBlock',
4455		blockquote: 'endTagBlock',
4456		button: 'endTagBlock',
4457		center: 'endTagBlock',
4458		details: 'endTagBlock',
4459		dir: 'endTagBlock',
4460		div: 'endTagBlock',
4461		dl: 'endTagBlock',
4462		fieldset: 'endTagBlock',
4463		figcaption: 'endTagBlock',
4464		figure: 'endTagBlock',
4465		footer: 'endTagBlock',
4466		header: 'endTagBlock',
4467		hgroup: 'endTagBlock',
4468		listing: 'endTagBlock',
4469		main: 'endTagBlock',
4470		menu: 'endTagBlock',
4471		nav: 'endTagBlock',
4472		ol: 'endTagBlock',
4473		pre: 'endTagBlock',
4474		section: 'endTagBlock',
4475		summary: 'endTagBlock',
4476		ul: 'endTagBlock',
4477		form: 'endTagForm',
4478		applet: 'endTagAppletMarqueeObject',
4479		marquee: 'endTagAppletMarqueeObject',
4480		object: 'endTagAppletMarqueeObject',
4481		dd: 'endTagListItem',
4482		dt: 'endTagListItem',
4483		li: 'endTagListItem',
4484		h1: 'endTagHeading',
4485		h2: 'endTagHeading',
4486		h3: 'endTagHeading',
4487		h4: 'endTagHeading',
4488		h5: 'endTagHeading',
4489		h6: 'endTagHeading',
4490		a: 'endTagFormatting',
4491		b: 'endTagFormatting',
4492		big: 'endTagFormatting',
4493		code: 'endTagFormatting',
4494		em: 'endTagFormatting',
4495		font: 'endTagFormatting',
4496		i: 'endTagFormatting',
4497		nobr: 'endTagFormatting',
4498		s: 'endTagFormatting',
4499		small: 'endTagFormatting',
4500		strike: 'endTagFormatting',
4501		strong: 'endTagFormatting',
4502		tt: 'endTagFormatting',
4503		u: 'endTagFormatting',
4504		br: 'endTagBr',
4505		"-default": 'endTagOther'
4506	};
4507
4508	modes.inBody.processCharacters = function(buffer) {
4509		if (tree.shouldSkipLeadingNewline) {
4510			tree.shouldSkipLeadingNewline = false;
4511			buffer.skipAtMostOneLeadingNewline();
4512		}
4513		tree.reconstructActiveFormattingElements();
4514		var characters = buffer.takeRemaining();
4515		characters = characters.replace(/\u0000/g, function(match, index){
4516			tree.parseError("invalid-codepoint");
4517			return '';
4518		});
4519		if (!characters)
4520			return;
4521		tree.insertText(characters);
4522		if (tree.framesetOk && !isAllWhitespaceOrReplacementCharacters(characters))
4523			tree.framesetOk = false;
4524	};
4525
4526	modes.inBody.startTagHtml = function(name, attributes) {
4527		tree.parseError('non-html-root');
4528		tree.addAttributesToElement(tree.openElements.rootNode, attributes);
4529	};
4530
4531	modes.inBody.startTagProcessInHead = function(name, attributes) {
4532		modes.inHead.processStartTag(name, attributes);
4533	};
4534
4535	modes.inBody.startTagBody = function(name, attributes) {
4536		tree.parseError('unexpected-start-tag', {name: 'body'});
4537		if (tree.openElements.length == 1 ||
4538			tree.openElements.item(1).localName != 'body') {
4539			assert.ok(tree.context);
4540		} else {
4541			tree.framesetOk = false;

4542			tree.addAttributesToElement(tree.openElements.bodyElement, attributes);
4543		}
4544	};
4545
4546	modes.inBody.startTagFrameset = function(name, attributes) {
4547		tree.parseError('unexpected-start-tag', {name: 'frameset'});
4548		if (tree.openElements.length == 1 ||
4549			tree.openElements.item(1).localName != 'body') {
4550			assert.ok(tree.context);
4551		} else if (tree.framesetOk) {
4552			tree.detachFromParent(tree.openElements.bodyElement);
4553			while (tree.openElements.length > 1)
4554				tree.openElements.pop();
4555			tree.insertElement(name, attributes);
4556			tree.setInsertionMode('inFrameset');
4557		}
4558	};
4559
4560	modes.inBody.startTagCloseP = function(name, attributes) {
4561		if (tree.openElements.inButtonScope('p'))
4562			this.endTagP('p');
4563		tree.insertElement(name, attributes);
4564	};
4565
4566	modes.inBody.startTagPreListing = function(name, attributes) {
4567		if (tree.openElements.inButtonScope('p'))
4568			this.endTagP('p');
4569		tree.insertElement(name, attributes);
4570		tree.framesetOk = false;
4571		tree.shouldSkipLeadingNewline = true;
4572	};
4573
4574	modes.inBody.startTagForm = function(name, attributes) {
4575		if (tree.form) {
4576			tree.parseError('unexpected-start-tag', {name: name});
4577		} else {
4578			if (tree.openElements.inButtonScope('p'))
4579				this.endTagP('p');
4580			tree.insertElement(name, attributes);
4581			tree.form = tree.currentStackItem();
4582		}
4583	};
4584
4585	modes.inBody.startTagRpRt = function(name, attributes) {
4586		if (tree.openElements.inScope('ruby')) {
4587			tree.generateImpliedEndTags();
4588			if (tree.currentStackItem().localName != 'ruby') {
4589				tree.parseError('unexpected-start-tag', {name: name});
4590			}
4591		}
4592		tree.insertElement(name, attributes);
4593	};
4594
4595	modes.inBody.startTagListItem = function(name, attributes) {
4596		var stopNames = {li: ['li'], dd: ['dd', 'dt'], dt: ['dd', 'dt']};
4597		var stopName = stopNames[name];
4598
4599		var els = tree.openElements;
4600		for (var i = els.length - 1; i >= 0; i--) {
4601			var node = els.item(i);
4602			if (stopName.indexOf(node.localName) != -1) {
4603				tree.insertionMode.processEndTag(node.localName);
4604				break;
4605			}
4606			if (node.isSpecial() && node.localName !== 'p' && node.localName !== 'address' && node.localName !== 'div')
4607				break;
4608		}
4609		if (tree.openElements.inButtonScope('p'))
4610			this.endTagP('p');
4611		tree.insertElement(name, attributes);
4612		tree.framesetOk = false;
4613	};
4614
4615	modes.inBody.startTagPlaintext = function(name, attributes) {
4616		if (tree.openElements.inButtonScope('p'))
4617			this.endTagP('p');
4618		tree.insertElement(name, attributes);
4619		tree.tokenizer.setState(Tokenizer.PLAINTEXT);
4620	};
4621
4622	modes.inBody.startTagHeading = function(name, attributes) {
4623		if (tree.openElements.inButtonScope('p'))
4624			this.endTagP('p');
4625		if (tree.currentStackItem().isNumberedHeader()) {
4626			tree.parseError('unexpected-start-tag', {name: name});
4627			tree.popElement();
4628		}
4629		tree.insertElement(name, attributes);
4630	};
4631
4632	modes.inBody.startTagA = function(name, attributes) {
4633		var activeA = tree.elementInActiveFormattingElements('a');
4634		if (activeA) {
4635			tree.parseError("unexpected-start-tag-implies-end-tag", {startName: "a", endName: "a"});
4636			tree.adoptionAgencyEndTag('a');
4637			if (tree.openElements.contains(activeA))
4638				tree.openElements.remove(activeA);
4639			tree.removeElementFromActiveFormattingElements(activeA);
4640		}
4641		tree.reconstructActiveFormattingElements();
4642		tree.insertFormattingElement(name, attributes);
4643	};
4644
4645	modes.inBody.startTagFormatting = function(name, attributes) {
4646		tree.reconstructActiveFormattingElements();
4647		tree.insertFormattingElement(name, attributes);
4648	};
4649
4650	modes.inBody.startTagNobr = function(name, attributes) {
4651		tree.reconstructActiveFormattingElements();
4652		if (tree.openElements.inScope('nobr')) {
4653			tree.parseError("unexpected-start-tag-implies-end-tag", {startName: 'nobr', endName: 'nobr'});
4654			this.processEndTag('nobr');
4655				tree.reconstructActiveFormattingElements();
4656		}
4657		tree.insertFormattingElement(name, attributes);
4658	};
4659
4660	modes.inBody.startTagButton = function(name, attributes) {
4661		if (tree.openElements.inScope('button')) {
4662			tree.parseError('unexpected-start-tag-implies-end-tag', {startName: 'button', endName: 'button'});
4663			this.processEndTag('button');
4664			tree.insertionMode.processStartTag(name, attributes);
4665		} else {
4666			tree.framesetOk = false;

4667			tree.reconstructActiveFormattingElements();
4668			tree.insertElement(name, attributes);
4669		}
4670	};
4671
4672	modes.inBody.startTagAppletMarqueeObject = function(name, attributes) {
4673		tree.reconstructActiveFormattingElements();
4674		tree.insertElement(name, attributes);
4675		tree.activeFormattingElements.push(Marker);
4676		tree.framesetOk = false;
4677	};
4678
4679	modes.inBody.endTagAppletMarqueeObject = function(name) {
4680		if (!tree.openElements.inScope(name)) {
4681			tree.parseError("unexpected-end-tag", {name: name});
4682		} else {
4683			tree.generateImpliedEndTags();
4684			if (tree.currentStackItem().localName != name) {
4685				tree.parseError('end-tag-too-early', {name: name});
4686			}
4687			tree.openElements.popUntilPopped(name);
4688			tree.clearActiveFormattingElements();
4689		}
4690	};
4691
4692	modes.inBody.startTagXmp = function(name, attributes) {
4693		if (tree.openElements.inButtonScope('p'))
4694			this.processEndTag('p');
4695		tree.reconstructActiveFormattingElements();
4696		tree.processGenericRawTextStartTag(name, attributes);
4697		tree.framesetOk = false;
4698	};
4699
4700	modes.inBody.startTagTable = function(name, attributes) {
4701		if (tree.compatMode !== "quirks")
4702			if (tree.openElements.inButtonScope('p'))
4703				this.processEndTag('p');
4704		tree.insertElement(name, attributes);
4705		tree.setInsertionMode('inTable');
4706		tree.framesetOk = false;
4707	};
4708
4709	modes.inBody.startTagVoidFormatting = function(name, attributes) {
4710		tree.reconstructActiveFormattingElements();
4711		tree.insertSelfClosingElement(name, attributes);
4712		tree.framesetOk = false;
4713	};
4714
4715	modes.inBody.startTagParamSourceTrack = function(name, attributes) {
4716		tree.insertSelfClosingElement(name, attributes);
4717	};
4718
4719	modes.inBody.startTagHr = function(name, attributes) {
4720		if (tree.openElements.inButtonScope('p'))
4721			this.endTagP('p');
4722		tree.insertSelfClosingElement(name, attributes);
4723		tree.framesetOk = false;
4724	};
4725
4726	modes.inBody.startTagImage = function(name, attributes) {
4727		tree.parseError('unexpected-start-tag-treated-as', {originalName: 'image', newName: 'img'});
4728		this.processStartTag('img', attributes);
4729	};
4730
4731	modes.inBody.startTagInput = function(name, attributes) {
4732		var currentFramesetOk = tree.framesetOk;
4733		this.startTagVoidFormatting(name, attributes);
4734		for (var key in attributes) {
4735			if (attributes[key].nodeName == 'type') {
4736				if (attributes[key].nodeValue.toLowerCase() == 'hidden')
4737					tree.framesetOk = currentFramesetOk;
4738				break;
4739			}
4740		}
4741	};
4742
4743	modes.inBody.startTagIsindex = function(name, attributes) {
4744		tree.parseError('deprecated-tag', {name: 'isindex'});
4745		tree.selfClosingFlagAcknowledged = true;
4746		if (tree.form)
4747			return;
4748		var formAttributes = [];
4749		var inputAttributes = [];
4750		var prompt = "This is a searchable index. Enter search keywords: ";
4751		for (var key in attributes) {
4752			switch (attributes[key].nodeName) {
4753				case 'action':
4754					formAttributes.push({nodeName: 'action',
4755						nodeValue: attributes[key].nodeValue});
4756					break;
4757				case 'prompt':
4758					prompt = attributes[key].nodeValue;
4759					break;
4760				case 'name':
4761					break;
4762				default:
4763					inputAttributes.push({nodeName: attributes[key].nodeName,
4764						nodeValue: attributes[key].nodeValue});
4765			}
4766		}
4767		inputAttributes.push({nodeName: 'name', nodeValue: 'isindex'});
4768		this.processStartTag('form', formAttributes);
4769		this.processStartTag('hr');
4770		this.processStartTag('label');
4771		this.processCharacters(new CharacterBuffer(prompt));
4772		this.processStartTag('input', inputAttributes);
4773		this.processEndTag('label');
4774		this.processStartTag('hr');
4775		this.processEndTag('form');
4776	};
4777
4778	modes.inBody.startTagTextarea = function(name, attributes) {
4779		tree.insertElement(name, attributes);
4780		tree.tokenizer.setState(Tokenizer.RCDATA);
4781		tree.originalInsertionMode = tree.insertionModeName;
4782		tree.shouldSkipLeadingNewline = true;
4783		tree.framesetOk = false;
4784		tree.setInsertionMode('text');
4785	};
4786
4787	modes.inBody.startTagIFrame = function(name, attributes) {
4788		tree.framesetOk = false;
4789		this.startTagRawText(name, attributes);
4790	};
4791
4792	modes.inBody.startTagRawText = function(name, attributes) {
4793		tree.processGenericRawTextStartTag(name, attributes);
4794	};
4795
4796	modes.inBody.startTagSelect = function(name, attributes) {
4797		tree.reconstructActiveFormattingElements();
4798		tree.insertElement(name, attributes);
4799		tree.framesetOk = false;

4800		var insertionModeName = tree.insertionModeName;
4801		if (insertionModeName == 'inTable' ||
4802			insertionModeName == 'inCaption' ||
4803			insertionModeName == 'inColumnGroup' ||
4804			insertionModeName == 'inTableBody' ||
4805			insertionModeName == 'inRow' ||
4806			insertionModeName == 'inCell') {
4807			tree.setInsertionMode('inSelectInTable');
4808		} else {
4809			tree.setInsertionMode('inSelect');
4810		}
4811	};
4812
4813	modes.inBody.startTagMisplaced = function(name, attributes) {
4814		tree.parseError('unexpected-start-tag-ignored', {name: name});
4815	};
4816
4817	modes.inBody.endTagMisplaced = function(name) {
4818		tree.parseError("unexpected-end-tag", {name: name});
4819	};
4820
4821	modes.inBody.endTagBr = function(name) {
4822		tree.parseError("unexpected-end-tag-treated-as", {originalName: "br", newName: "br element"});
4823		tree.reconstructActiveFormattingElements();
4824		tree.insertElement(name, []);
4825		tree.popElement();
4826	};
4827
4828	modes.inBody.startTagOptionOptgroup = function(name, attributes) {
4829		if (tree.currentStackItem().localName == 'option')
4830			tree.popElement();
4831		tree.reconstructActiveFormattingElements();
4832		tree.insertElement(name, attributes);
4833	};
4834
4835	modes.inBody.startTagOther = function(name, attributes) {
4836		tree.reconstructActiveFormattingElements();
4837		tree.insertElement(name, attributes);
4838	};
4839
4840	modes.inBody.endTagOther = function(name) {
4841		var node;
4842		for (var i = tree.openElements.length - 1; i > 0; i--) {
4843			node = tree.openElements.item(i);
4844			if (node.localName == name) {
4845				tree.generateImpliedEndTags(name);
4846				if (tree.currentStackItem().localName != name)
4847					tree.parseError('unexpected-end-tag', {name: name});
4848				tree.openElements.remove_openElements_until(function(x) {return x === node;});
4849				break;
4850			}
4851			if (node.isSpecial()) {
4852				tree.parseError('unexpected-end-tag', {name: name});
4853				break;
4854			}
4855		}
4856	};
4857
4858	modes.inBody.startTagMath = function(name, attributes, selfClosing) {
4859		tree.reconstructActiveFormattingElements();
4860		attributes = tree.adjustMathMLAttributes(attributes);
4861		attributes = tree.adjustForeignAttributes(attributes);
4862		tree.insertForeignElement(name, attributes, "http://www.w3.org/1998/Math/MathML", selfClosing);
4863	};
4864
4865	modes.inBody.startTagSVG = function(name, attributes, selfClosing) {
4866		tree.reconstructActiveFormattingElements();
4867		attributes = tree.adjustSVGAttributes(attributes);
4868		attributes = tree.adjustForeignAttributes(attributes);
4869		tree.insertForeignElement(name, attributes, "http://www.w3.org/2000/svg", selfClosing);
4870	};
4871
4872	modes.inBody.endTagP = function(name) {
4873		if (!tree.openElements.inButtonScope('p')) {
4874			tree.parseError('unexpected-end-tag', {name: 'p'});
4875			this.startTagCloseP('p', []);
4876			this.endTagP('p');
4877		} else {
4878			tree.generateImpliedEndTags('p');
4879			if (tree.currentStackItem().localName != 'p')
4880				tree.parseError('unexpected-implied-end-tag', {name: 'p'});
4881			tree.openElements.popUntilPopped(name);
4882		}
4883	};
4884
4885	modes.inBody.endTagBody = function(name) {
4886		if (!tree.openElements.inScope('body')) {
4887			tree.parseError('unexpected-end-tag', {name: name});
4888			return;
4889		}
4890		if (tree.currentStackItem().localName != 'body') {
4891			tree.parseError('expected-one-end-tag-but-got-another', {
4892				expectedName: tree.currentStackItem().localName,
4893				gotName: name
4894			});
4895		}
4896		tree.setInsertionMode('afterBody');
4897	};
4898
4899	modes.inBody.endTagHtml = function(name) {
4900		if (!tree.openElements.inScope('body')) {
4901			tree.parseError('unexpected-end-tag', {name: name});
4902			return;
4903		}
4904		if (tree.currentStackItem().localName != 'body') {
4905			tree.parseError('expected-one-end-tag-but-got-another', {
4906				expectedName: tree.currentStackItem().localName,
4907				gotName: name
4908			});
4909		}
4910		tree.setInsertionMode('afterBody');
4911		tree.insertionMode.processEndTag(name);
4912	};
4913
4914	modes.inBody.endTagBlock = function(name) {
4915		if (!tree.openElements.inScope(name)) {
4916			tree.parseError('unexpected-end-tag', {name: name});
4917		} else {
4918			tree.generateImpliedEndTags();
4919			if (tree.currentStackItem().localName != name) {
4920				tree.parseError('end-tag-too-early', {name: name});
4921			}
4922			tree.openElements.popUntilPopped(name);
4923		}
4924	};
4925
4926	modes.inBody.endTagForm = function(name)  {
4927		var node = tree.form;
4928		tree.form = null;
4929		if (!node || !tree.openElements.inScope(name)) {
4930			tree.parseError('unexpected-end-tag', {name: name});
4931		} else {
4932			tree.generateImpliedEndTags();
4933			if (tree.currentStackItem() != node) {
4934				tree.parseError('end-tag-too-early-ignored', {name: 'form'});
4935			}
4936			tree.openElements.remove(node);
4937		}
4938	};
4939
4940	modes.inBody.endTagListItem = function(name) {
4941		if (!tree.openElements.inListItemScope(name)) {
4942			tree.parseError('unexpected-end-tag', {name: name});
4943		} else {
4944			tree.generateImpliedEndTags(name);
4945			if (tree.currentStackItem().localName != name)
4946				tree.parseError('end-tag-too-early', {name: name});
4947			tree.openElements.popUntilPopped(name);
4948		}
4949	};
4950
4951	modes.inBody.endTagHeading = function(name) {
4952		if (!tree.openElements.hasNumberedHeaderElementInScope()) {
4953			tree.parseError('unexpected-end-tag', {name: name});
4954			return;
4955		}
4956		tree.generateImpliedEndTags();
4957		if (tree.currentStackItem().localName != name)
4958			tree.parseError('end-tag-too-early', {name: name});
4959
4960		tree.openElements.remove_openElements_until(function(e) {
4961			return e.isNumberedHeader();
4962		});
4963	};
4964
4965	modes.inBody.endTagFormatting = function(name, attributes) {
4966		if (!tree.adoptionAgencyEndTag(name))
4967			this.endTagOther(name, attributes);
4968	};
4969
4970	modes.inCaption = Object.create(modes.base);
4971
4972	modes.inCaption.start_tag_handlers = {
4973		html: 'startTagHtml',
4974		caption: 'startTagTableElement',
4975		col: 'startTagTableElement',
4976		colgroup: 'startTagTableElement',
4977		tbody: 'startTagTableElement',
4978		td: 'startTagTableElement',
4979		tfoot: 'startTagTableElement',
4980		thead: 'startTagTableElement',

4981		tr: 'startTagTableElement',
4982		'-default': 'startTagOther'
4983	};
4984
4985	modes.inCaption.end_tag_handlers = {
4986		caption: 'endTagCaption',
4987		table: 'endTagTable',
4988		body: 'endTagIgnore',
4989		col: 'endTagIgnore',
4990		colgroup: 'endTagIgnore',
4991		html: 'endTagIgnore',
4992		tbody: 'endTagIgnore',
4993		td: 'endTagIgnore',
4994		tfood: 'endTagIgnore',
4995		thead: 'endTagIgnore',
4996		tr: 'endTagIgnore',
4997		'-default': 'endTagOther'
4998	};
4999
5000	modes.inCaption.processCharacters = function(data) {
5001		modes.inBody.processCharacters(data);
5002	};
5003
5004	modes.inCaption.startTagTableElement = function(name, attributes) {
5005		tree.parseError('unexpected-end-tag', {name: name});
5006		var ignoreEndTag = !tree.openElements.inTableScope('caption');
5007		tree.insertionMode.processEndTag('caption');
5008		if (!ignoreEndTag) tree.insertionMode.processStartTag(name, attributes);
5009	};
5010
5011	modes.inCaption.startTagOther = function(name, attributes, selfClosing) {
5012		modes.inBody.processStartTag(name, attributes, selfClosing);
5013	};
5014
5015	modes.inCaption.endTagCaption = function(name) {
5016		if (!tree.openElements.inTableScope('caption')) {
5017			assert.ok(tree.context);
5018			tree.parseError('unexpected-end-tag', {name: name});
5019		} else {
5020			tree.generateImpliedEndTags();
5021			if (tree.currentStackItem().localName != 'caption') {
5022				tree.parseError('expected-one-end-tag-but-got-another', {
5023					gotName: "caption",
5024					expectedName: tree.currentStackItem().localName
5025				});
5026			}
5027			tree.openElements.popUntilPopped('caption');
5028			tree.clearActiveFormattingElements();
5029			tree.setInsertionMode('inTable');
5030		}
5031	};
5032
5033	modes.inCaption.endTagTable = function(name) {
5034		tree.parseError("unexpected-end-table-in-caption");
5035		var ignoreEndTag = !tree.openElements.inTableScope('caption');
5036		tree.insertionMode.processEndTag('caption');
5037		if (!ignoreEndTag) tree.insertionMode.processEndTag(name);
5038	};
5039
5040	modes.inCaption.endTagIgnore = function(name) {
5041		tree.parseError('unexpected-end-tag', {name: name});
5042	};
5043
5044	modes.inCaption.endTagOther = function(name) {
5045		modes.inBody.processEndTag(name);
5046	};
5047
5048	modes.inCell = Object.create(modes.base);
5049
5050	modes.inCell.start_tag_handlers = {
5051		html: 'startTagHtml',
5052		caption: 'startTagTableOther',
5053		col: 'startTagTableOther',
5054		colgroup: 'startTagTableOther',
5055		tbody: 'startTagTableOther',
5056		td: 'startTagTableOther',
5057		tfoot: 'startTagTableOther',
5058		th: 'startTagTableOther',
5059		thead: 'startTagTableOther',
5060		tr: 'startTagTableOther',
5061		'-default': 'startTagOther'
5062	};
5063
5064	modes.inCell.end_tag_handlers = {
5065		td: 'endTagTableCell',
5066		th: 'endTagTableCell',
5067		body: 'endTagIgnore',
5068		caption: 'endTagIgnore',
5069		col: 'endTagIgnore',
5070		colgroup: 'endTagIgnore',
5071		html: 'endTagIgnore',
5072		table: 'endTagImply',
5073		tbody: 'endTagImply',
5074		tfoot: 'endTagImply',
5075		thead: 'endTagImply',
5076		tr: 'endTagImply',
5077		'-default': 'endTagOther'
5078	};
5079
5080	modes.inCell.processCharacters = function(data) {
5081		modes.inBody.processCharacters(data);
5082	};
5083
5084	modes.inCell.startTagTableOther = function(name, attributes, selfClosing) {
5085		if (tree.openElements.inTableScope('td') || tree.openElements.inTableScope('th')) {
5086			this.closeCell();
5087			tree.insertionMode.processStartTag(name, attributes, selfClosing);
5088		} else {
5089			tree.parseError('unexpected-start-tag', {name: name});
5090		}
5091	};
5092
5093	modes.inCell.startTagOther = function(name, attributes, selfClosing) {
5094		modes.inBody.processStartTag(name, attributes, selfClosing);
5095	};
5096
5097	modes.inCell.endTagTableCell = function(name) {
5098		if (tree.openElements.inTableScope(name)) {
5099			tree.generateImpliedEndTags(name);
5100			if (tree.currentStackItem().localName != name.toLowerCase()) {
5101				tree.parseError('unexpected-cell-end-tag', {name: name});
5102				tree.openElements.popUntilPopped(name);
5103			} else {
5104				tree.popElement();
5105			}
5106			tree.clearActiveFormattingElements();
5107			tree.setInsertionMode('inRow');
5108		} else {
5109			tree.parseError('unexpected-end-tag', {name: name});
5110		}
5111	};
5112
5113	modes.inCell.endTagIgnore = function(name) {
5114		tree.parseError('unexpected-end-tag', {name: name});
5115	};
5116
5117	modes.inCell.endTagImply = function(name) {
5118		if (tree.openElements.inTableScope(name)) {
5119			this.closeCell();
5120			tree.insertionMode.processEndTag(name);
5121		} else {
5122			tree.parseError('unexpected-end-tag', {name: name});
5123		}
5124	};
5125
5126	modes.inCell.endTagOther = function(name) {
5127		modes.inBody.processEndTag(name);
5128	};
5129
5130	modes.inCell.closeCell = function() {
5131		if (tree.openElements.inTableScope('td')) {
5132			this.endTagTableCell('td');
5133		} else if (tree.openElements.inTableScope('th')) {
5134			this.endTagTableCell('th');
5135		}
5136	};
5137
5138
5139	modes.inColumnGroup = Object.create(modes.base);
5140
5141	modes.inColumnGroup.start_tag_handlers = {
5142		html: 'startTagHtml',
5143		col: 'startTagCol',
5144		'-default': 'startTagOther'
5145	};
5146
5147	modes.inColumnGroup.end_tag_handlers = {
5148		colgroup: 'endTagColgroup',

5149		col: 'endTagCol',
5150		'-default': 'endTagOther'
5151	};
5152
5153	modes.inColumnGroup.ignoreEndTagColgroup = function() {
5154		return tree.currentStackItem().localName == 'html';
5155	};
5156
5157	modes.inColumnGroup.processCharacters = function(buffer) {
5158		var leadingWhitespace = buffer.takeLeadingWhitespace();
5159		if (leadingWhitespace)
5160			tree.insertText(leadingWhitespace);
5161		if (!buffer.length)
5162			return;
5163		var ignoreEndTag = this.ignoreEndTagColgroup();
5164		this.endTagColgroup('colgroup');
5165		if (!ignoreEndTag) tree.insertionMode.processCharacters(buffer);
5166	};
5167
5168	modes.inColumnGroup.startTagCol = function(name, attributes) {
5169		tree.insertSelfClosingElement(name, attributes);
5170	};
5171
5172	modes.inColumnGroup.startTagOther = function(name, attributes, selfClosing) {
5173		var ignoreEndTag = this.ignoreEndTagColgroup();
5174		this.endTagColgroup('colgroup');
5175		if (!ignoreEndTag) tree.insertionMode.processStartTag(name, attributes, selfClosing);
5176	};
5177
5178	modes.inColumnGroup.endTagColgroup = function(name) {
5179		if (this.ignoreEndTagColgroup()) {
5180			assert.ok(tree.context);
5181			tree.parseError('unexpected-end-tag', {name: name});
5182		} else {
5183			tree.popElement();
5184			tree.setInsertionMode('inTable');
5185		}
5186	};
5187
5188	modes.inColumnGroup.endTagCol = function(name) {
5189		tree.parseError("no-end-tag", {name: 'col'});
5190	};
5191
5192	modes.inColumnGroup.endTagOther = function(name) {
5193		var ignoreEndTag = this.ignoreEndTagColgroup();
5194		this.endTagColgroup('colgroup');
5195		if (!ignoreEndTag) tree.insertionMode.processEndTag(name) ;
5196	};
5197
5198	modes.inForeignContent = Object.create(modes.base);
5199
5200	modes.inForeignContent.processStartTag = function(name, attributes, selfClosing) {
5201		if (['b', 'big', 'blockquote', 'body', 'br', 'center', 'code', 'dd', 'div', 'dl', 'dt', 'em', 'embed', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'hr', 'i', 'img', 'li', 'listing', 'menu', 'meta', 'nobr', 'ol', 'p', 'pre', 'ruby', 's', 'small', 'span', 'strong', 'strike', 'sub', 'sup', 'table', 'tt', 'u', 'ul', 'var'].indexOf(name) != -1
5202				|| (name == 'font' && attributes.some(function(attr){ return ['color', 'face', 'size'].indexOf(attr.nodeName) >= 0 }))) {
5203			tree.parseError('unexpected-html-element-in-foreign-content', {name: name});
5204			while (tree.currentStackItem().isForeign()
5205				&& !tree.currentStackItem().isHtmlIntegrationPoint()
5206				&& !tree.currentStackItem().isMathMLTextIntegrationPoint()) {
5207				tree.openElements.pop();
5208			}
5209			tree.insertionMode.processStartTag(name, attributes, selfClosing);
5210			return;
5211		}
5212		if (tree.currentStackItem().namespaceURI == "http://www.w3.org/1998/Math/MathML") {
5213			attributes = tree.adjustMathMLAttributes(attributes);
5214		}
5215		if (tree.currentStackItem().namespaceURI == "http://www.w3.org/2000/svg") {
5216			name = tree.adjustSVGTagNameCase(name);
5217			attributes = tree.adjustSVGAttributes(attributes);
5218		}
5219		attributes = tree.adjustForeignAttributes(attributes);
5220		tree.insertForeignElement(name, attributes, tree.currentStackItem().namespaceURI, selfClosing);
5221	};
5222
5223	modes.inForeignContent.processEndTag = function(name) {
5224		var node = tree.currentStackItem();
5225		var index = tree.openElements.length - 1;
5226		if (node.localName.toLowerCase() != name)
5227			tree.parseError("unexpected-end-tag", {name: name});
5228
5229		while (true) {
5230			if (index === 0)
5231				break;
5232			if (node.localName.toLowerCase() == name) {
5233				while (tree.openElements.pop() != node);
5234				break;
5235			}
5236			index -= 1;
5237			node = tree.openElements.item(index);
5238			if (node.isForeign()) {
5239				continue;
5240			} else {
5241				tree.insertionMode.processEndTag(name);
5242				break;
5243			}
5244		}
5245	};
5246
5247	modes.inForeignContent.processCharacters = function(buffer) {
5248		var characters = buffer.takeRemaining();
5249		characters = characters.replace(/\u0000/g, function(match, index){
5250			tree.parseError('invalid-codepoint');
5251			return '\uFFFD';
5252		});
5253		if (tree.framesetOk && !isAllWhitespaceOrReplacementCharacters(characters))
5254			tree.framesetOk = false;
5255		tree.insertText(characters);
5256	};
5257
5258	modes.inHeadNoscript = Object.create(modes.base);
5259
5260	modes.inHeadNoscript.start_tag_handlers = {
5261		html: 'startTagHtml',
5262		basefont: 'startTagBasefontBgsoundLinkMetaNoframesStyle',
5263		bgsound: 'startTagBasefontBgsoundLinkMetaNoframesStyle',
5264		link: 'startTagBasefontBgsoundLinkMetaNoframesStyle',
5265		meta: 'startTagBasefontBgsoundLinkMetaNoframesStyle',
5266		noframes: 'startTagBasefontBgsoundLinkMetaNoframesStyle',
5267		style: 'startTagBasefontBgsoundLinkMetaNoframesStyle',
5268		head: 'startTagHeadNoscript',
5269		noscript: 'startTagHeadNoscript',
5270		"-default": 'startTagOther'
5271	};
5272
5273	modes.inHeadNoscript.end_tag_handlers = {
5274		noscript: 'endTagNoscript',
5275		br: 'endTagBr',
5276		'-default': 'endTagOther'
5277	};
5278
5279	modes.inHeadNoscript.processCharacters = function(buffer) {
5280		var leadingWhitespace = buffer.takeLeadingWhitespace();
5281		if (leadingWhitespace)
5282			tree.insertText(leadingWhitespace);
5283		if (!buffer.length)
5284			return;
5285		tree.parseError("unexpected-char-in-frameset");
5286		this.anythingElse();
5287		tree.insertionMode.processCharacters(buffer);
5288	};
5289
5290	modes.inHeadNoscript.processComment = function(data) {
5291		modes.inHead.processComment(data);
5292	};
5293
5294	modes.inHeadNoscript.startTagBasefontBgsoundLinkMetaNoframesStyle = function(name, attributes) {
5295		modes.inHead.processStartTag(name, attributes);
5296	};
5297
5298	modes.inHeadNoscript.startTagHeadNoscript = function(name, attributes) {
5299		tree.parseError("unexpected-start-tag-in-frameset", {name: name});
5300	};
5301
5302	modes.inHeadNoscript.startTagOther = function(name, attributes) {
5303		tree.parseError("unexpected-start-tag-in-frameset", {name: name});
5304		this.anythingElse();
5305		tree.insertionMode.processStartTag(name, attributes);
5306	};
5307
5308	modes.inHeadNoscript.endTagBr = function(name, attributes) {
5309		tree.parseError("unexpected-end-tag-in-frameset", {name: name});
5310		this.anythingElse();
5311		tree.insertionMode.processEndTag(name, attributes);
5312	};
5313
5314	modes.inHeadNoscript.endTagNoscript = function(name, attributes) {
5315		tree.popElement();
5316		tree.setInsertionMode('inHead');
5317	};
5318
5319	modes.inHeadNoscript.endTagOther = function(name, attributes) {
5320		tree.parseError("unexpected-end-tag-in-frameset", {name: name});
5321	};
5322
5323	modes.inHeadNoscript.anythingElse = function() {
5324		tree.popElement();
5325		tree.setInsertionMode('inHead');
5326	};
5327
5328
5329	modes.inFrameset = Object.create(modes.base);
5330
5331	modes.inFrameset.start_tag_handlers = {
5332		html: 'startTagHtml',
5333		frameset: 'startTagFrameset',
5334		frame: 'startTagFrame',
5335		noframes: 'startTagNoframes',
5336		"-default": 'startTagOther'
5337	};
5338
5339	modes.inFrameset.end_tag_handlers = {
5340		frameset: 'endTagFrameset',
5341		noframes: 'endTagNoframes',
5342		'-default': 'endTagOther'
5343	};
5344
5345	modes.inFrameset.processCharacters = function(data) {
5346		tree.parseError("unexpected-char-in-frameset");
5347	};
5348
5349	modes.inFrameset.startTagFrameset = function(name, attributes) {
5350		tree.insertElement(name, attributes);
5351	};
5352
5353	modes.inFrameset.startTagFrame = function(name, attributes) {
5354		tree.insertSelfClosingElement(name, attributes);
5355	};
5356
5357	modes.inFrameset.startTagNoframes = function(name, attributes) {
5358		modes.inBody.processStartTag(name, attributes);
5359	};
5360
5361	modes.inFrameset.startTagOther = function(name, attributes) {
5362		tree.parseError("unexpected-start-tag-in-frameset", {name: name});
5363	};
5364
5365	modes.inFrameset.endTagFrameset = function(name, attributes) {
5366		if (tree.currentStackItem().localName == 'html') {
5367			tree.parseError("unexpected-frameset-in-frameset-innerhtml");
5368		} else {
5369			tree.popElement();
5370		}
5371
5372		if (!tree.context && tree.currentStackItem().localName != 'frameset') {
5373			tree.setInsertionMode('afterFrameset');
5374		}
5375	};
5376
5377	modes.inFrameset.endTagNoframes = function(name) {
5378		modes.inBody.processEndTag(name);
5379	};
5380
5381	modes.inFrameset.endTagOther = function(name) {
5382		tree.parseError("unexpected-end-tag-in-frameset", {name: name});
5383	};
5384
5385	modes.inTable = Object.create(modes.base);
5386
5387	modes.inTable.start_tag_handlers = {
5388		html: 'startTagHtml',
5389		caption: 'startTagCaption',

5390		colgroup: 'startTagColgroup',
5391		col: 'startTagCol',
5392		table: 'startTagTable',
5393		tbody: 'startTagRowGroup',
5394		tfoot: 'startTagRowGroup',
5395		thead: 'startTagRowGroup',
5396		td: 'startTagImplyTbody',
5397		th: 'startTagImplyTbody',
5398		tr: 'startTagImplyTbody',
5399		style: 'startTagStyleScript',
5400		script: 'startTagStyleScript',
5401		input: 'startTagInput',
5402		form: 'startTagForm',
5403		'-default': 'startTagOther'
5404	};
5405
5406	modes.inTable.end_tag_handlers = {
5407		table: 'endTagTable',
5408		body: 'endTagIgnore',
5409		caption: 'endTagIgnore',
5410		col: 'endTagIgnore',
5411		colgroup: 'endTagIgnore',
5412		html: 'endTagIgnore',
5413		tbody: 'endTagIgnore',
5414		td: 'endTagIgnore',
5415		tfoot: 'endTagIgnore',
5416		th: 'endTagIgnore',
5417		thead: 'endTagIgnore',
5418		tr: 'endTagIgnore',
5419		'-default': 'endTagOther'
5420	};
5421
5422	modes.inTable.processCharacters =  function(data) {
5423		if (tree.currentStackItem().isFosterParenting()) {
5424			var originalInsertionMode = tree.insertionModeName;
5425			tree.setInsertionMode('inTableText');
5426			tree.originalInsertionMode = originalInsertionMode;
5427			tree.insertionMode.processCharacters(data);
5428		} else {
5429			tree.redirectAttachToFosterParent = true;
5430			modes.inBody.processCharacters(data);
5431			tree.redirectAttachToFosterParent = false;
5432		}
5433	};
5434
5435	modes.inTable.startTagCaption = function(name, attributes) {
5436		tree.openElements.popUntilTableScopeMarker();
5437		tree.activeFormattingElements.push(Marker);
5438		tree.insertElement(name, attributes);
5439		tree.setInsertionMode('inCaption');
5440	};
5441
5442	modes.inTable.startTagColgroup = function(name, attributes) {
5443		tree.openElements.popUntilTableScopeMarker();
5444		tree.insertElement(name, attributes);
5445		tree.setInsertionMode('inColumnGroup');
5446	};
5447
5448	modes.inTable.startTagCol = function(name, attributes) {
5449		this.startTagColgroup('colgroup', []);
5450		tree.insertionMode.processStartTag(name, attributes);
5451	};
5452
5453	modes.inTable.startTagRowGroup = function(name, attributes) {
5454		tree.openElements.popUntilTableScopeMarker();
5455		tree.insertElement(name, attributes);
5456		tree.setInsertionMode('inTableBody');
5457	};
5458
5459	modes.inTable.startTagImplyTbody = function(name, attributes) {
5460		this.startTagRowGroup('tbody', []);
5461		tree.insertionMode.processStartTag(name, attributes);
5462	};
5463
5464	modes.inTable.startTagTable = function(name, attributes) {
5465		tree.parseError("unexpected-start-tag-implies-end-tag",
5466				{startName: "table", endName: "table"});
5467		tree.insertionMode.processEndTag('table');
5468		if (!tree.context) tree.insertionMode.processStartTag(name, attributes);
5469	};
5470
5471	modes.inTable.startTagStyleScript = function(name, attributes) {
5472		modes.inHead.processStartTag(name, attributes);
5473	};
5474
5475	modes.inTable.startTagInput = function(name, attributes) {
5476		for (var key in attributes) {
5477			if (attributes[key].nodeName.toLowerCase() == 'type') {
5478				if (attributes[key].nodeValue.toLowerCase() == 'hidden') {
5479					tree.parseError("unexpected-hidden-input-in-table");
5480					tree.insertElement(name, attributes);
5481					tree.openElements.pop();
5482					return;
5483				}
5484				break;
5485			}
5486		}
5487		this.startTagOther(name, attributes);
5488	};
5489
5490	modes.inTable.startTagForm = function(name, attributes) {
5491		tree.parseError("unexpected-form-in-table");
5492		if (!tree.form) {
5493			tree.insertElement(name, attributes);
5494			tree.form = tree.currentStackItem();
5495			tree.openElements.pop();
5496		}
5497	};
5498
5499	modes.inTable.startTagOther = function(name, attributes, selfClosing) {
5500		tree.parseError("unexpected-start-tag-implies-table-voodoo", {name: name});
5501		tree.redirectAttachToFosterParent = true;
5502		modes.inBody.processStartTag(name, attributes, selfClosing);
5503		tree.redirectAttachToFosterParent = false;
5504	};
5505
5506	modes.inTable.endTagTable = function(name) {
5507		if (tree.openElements.inTableScope(name)) {
5508			tree.generateImpliedEndTags();
5509			if (tree.currentStackItem().localName != name) {
5510				tree.parseError("end-tag-too-early-named", {gotName: 'table', expectedName: tree.currentStackItem().localName});
5511			}
5512
5513			tree.openElements.popUntilPopped('table');
5514			tree.resetInsertionMode();
5515		} else {
5516			assert.ok(tree.context);
5517			tree.parseError('unexpected-end-tag', {name: name});
5518		}
5519	};
5520
5521	modes.inTable.endTagIgnore = function(name) {
5522		tree.parseError("unexpected-end-tag", {name: name});
5523	};
5524
5525	modes.inTable.endTagOther = function(name) {
5526		tree.parseError("unexpected-end-tag-implies-table-voodoo", {name: name});
5527		tree.redirectAttachToFosterParent = true;
5528		modes.inBody.processEndTag(name);
5529		tree.redirectAttachToFosterParent = false;

5530	};
5531
5532	modes.inTableText = Object.create(modes.base);
5533
5534	modes.inTableText.flushCharacters = function() {
5535		var characters = tree.pendingTableCharacters.join('');
5536		if (!isAllWhitespace(characters)) {
5537			tree.redirectAttachToFosterParent = true;
5538			tree.reconstructActiveFormattingElements();
5539			tree.insertText(characters);
5540			tree.framesetOk = false;
5541			tree.redirectAttachToFosterParent = false;
5542		} else {
5543			tree.insertText(characters);
5544		}
5545		tree.pendingTableCharacters = [];
5546	};
5547
5548	modes.inTableText.processComment = function(data) {
5549		this.flushCharacters();
5550		tree.setInsertionMode(tree.originalInsertionMode);
5551		tree.insertionMode.processComment(data);
5552	};
5553
5554	modes.inTableText.processEOF = function(data) {
5555		this.flushCharacters();
5556		tree.setInsertionMode(tree.originalInsertionMode);
5557		tree.insertionMode.processEOF();
5558	};
5559
5560	modes.inTableText.processCharacters = function(buffer) {
5561		var characters = buffer.takeRemaining();
5562		characters = characters.replace(/\u0000/g, function(match, index){
5563			tree.parseError("invalid-codepoint");
5564			return '';
5565		});
5566		if (!characters)
5567			return;
5568		tree.pendingTableCharacters.push(characters);
5569	};
5570
5571	modes.inTableText.processStartTag = function(name, attributes, selfClosing) {
5572		this.flushCharacters();
5573		tree.setInsertionMode(tree.originalInsertionMode);
5574		tree.insertionMode.processStartTag(name, attributes, selfClosing);
5575	};
5576
5577	modes.inTableText.processEndTag = function(name, attributes) {
5578		this.flushCharacters();
5579		tree.setInsertionMode(tree.originalInsertionMode);
5580		tree.insertionMode.processEndTag(name, attributes);
5581	};
5582
5583	modes.inTableBody = Object.create(modes.base);
5584
5585	modes.inTableBody.start_tag_handlers = {
5586		html: 'startTagHtml',

5587		tr: 'startTagTr',
5588		td: 'startTagTableCell',
5589		th: 'startTagTableCell',
5590		caption: 'startTagTableOther',
5591		col: 'startTagTableOther',
5592		colgroup: 'startTagTableOther',
5593		tbody: 'startTagTableOther',
5594		tfoot: 'startTagTableOther',
5595		thead: 'startTagTableOther',
5596		'-default': 'startTagOther'
5597	};
5598
5599	modes.inTableBody.end_tag_handlers = {
5600		table: 'endTagTable',
5601		tbody: 'endTagTableRowGroup',
5602		tfoot: 'endTagTableRowGroup',
5603		thead: 'endTagTableRowGroup',
5604		body: 'endTagIgnore',
5605		caption: 'endTagIgnore',
5606		col: 'endTagIgnore',
5607		colgroup: 'endTagIgnore',
5608		html: 'endTagIgnore',
5609		td: 'endTagIgnore',
5610		th: 'endTagIgnore',
5611		tr: 'endTagIgnore',
5612		'-default': 'endTagOther'
5613	};
5614
5615	modes.inTableBody.processCharacters = function(data) {
5616		modes.inTable.processCharacters(data);
5617	};
5618
5619	modes.inTableBody.startTagTr = function(name, attributes) {
5620		tree.openElements.popUntilTableBodyScopeMarker();
5621		tree.insertElement(name, attributes);
5622		tree.setInsertionMode('inRow');
5623	};
5624
5625	modes.inTableBody.startTagTableCell = function(name, attributes) {
5626		tree.parseError("unexpected-cell-in-table-body", {name: name});
5627		this.startTagTr('tr', []);
5628		tree.insertionMode.processStartTag(name, attributes);
5629	};
5630
5631	modes.inTableBody.startTagTableOther = function(name, attributes) {
5632		if (tree.openElements.inTableScope('tbody') ||  tree.openElements.inTableScope('thead') || tree.openElements.inTableScope('tfoot')) {
5633			tree.openElements.popUntilTableBodyScopeMarker();
5634			this.endTagTableRowGroup(tree.currentStackItem().localName);
5635			tree.insertionMode.processStartTag(name, attributes);
5636		} else {
5637			tree.parseError('unexpected-start-tag', {name: name});
5638		}
5639	};
5640
5641	modes.inTableBody.startTagOther = function(name, attributes) {
5642		modes.inTable.processStartTag(name, attributes);
5643	};
5644
5645	modes.inTableBody.endTagTableRowGroup = function(name) {
5646		if (tree.openElements.inTableScope(name)) {
5647			tree.openElements.popUntilTableBodyScopeMarker();
5648			tree.popElement();
5649			tree.setInsertionMode('inTable');
5650		} else {
5651			tree.parseError('unexpected-end-tag-in-table-body', {name: name});
5652		}
5653	};
5654
5655	modes.inTableBody.endTagTable = function(name) {
5656		if (tree.openElements.inTableScope('tbody') ||  tree.openElements.inTableScope('thead') || tree.openElements.inTableScope('tfoot')) {
5657			tree.openElements.popUntilTableBodyScopeMarker();
5658			this.endTagTableRowGroup(tree.currentStackItem().localName);
5659			tree.insertionMode.processEndTag(name);
5660		} else {
5661			tree.parseError('unexpected-end-tag', {name: name});
5662		}
5663	};
5664
5665	modes.inTableBody.endTagIgnore = function(name) {
5666		tree.parseError("unexpected-end-tag-in-table-body", {name: name});
5667	};
5668
5669	modes.inTableBody.endTagOther = function(name) {
5670		modes.inTable.processEndTag(name);
5671	};
5672
5673	modes.inSelect = Object.create(modes.base);
5674
5675	modes.inSelect.start_tag_handlers = {
5676		html: 'startTagHtml',
5677		option: 'startTagOption',
5678		optgroup: 'startTagOptgroup',
5679		select: 'startTagSelect',
5680		input: 'startTagInput',
5681		keygen: 'startTagInput',
5682		textarea: 'startTagInput',
5683		script: 'startTagScript',
5684		'-default': 'startTagOther'
5685	};
5686
5687	modes.inSelect.end_tag_handlers = {
5688		option: 'endTagOption',
5689		optgroup: 'endTagOptgroup',
5690		select: 'endTagSelect',
5691		caption: 'endTagTableElements',
5692		table: 'endTagTableElements',
5693		tbody: 'endTagTableElements',
5694		tfoot: 'endTagTableElements',
5695		thead: 'endTagTableElements',
5696		tr: 'endTagTableElements',
5697		td: 'endTagTableElements',
5698		th: 'endTagTableElements',
5699		'-default': 'endTagOther'
5700	};
5701
5702	modes.inSelect.processCharacters = function(buffer) {
5703		var data = buffer.takeRemaining();
5704		data = data.replace(/\u0000/g, function(match, index){
5705			tree.parseError("invalid-codepoint");
5706			return '';
5707		});
5708		if (!data)
5709			return;
5710		tree.insertText(data);
5711	};
5712
5713	modes.inSelect.startTagOption = function(name, attributes) {
5714		if (tree.currentStackItem().localName == 'option')
5715			tree.popElement();
5716		tree.insertElement(name, attributes);
5717	};
5718
5719	modes.inSelect.startTagOptgroup = function(name, attributes) {
5720		if (tree.currentStackItem().localName == 'option')
5721			tree.popElement();
5722		if (tree.currentStackItem().localName == 'optgroup')
5723			tree.popElement();
5724		tree.insertElement(name, attributes);
5725	};
5726
5727	modes.inSelect.endTagOption = function(name) {
5728		if (tree.currentStackItem().localName !== 'option') {
5729			tree.parseError('unexpected-end-tag-in-select', {name: name});
5730			return;
5731		}
5732		tree.popElement();
5733	};
5734
5735	modes.inSelect.endTagOptgroup = function(name) {
5736		if (tree.currentStackItem().localName == 'option' && tree.openElements.item(tree.openElements.length - 2).localName == 'optgroup') {
5737			tree.popElement();
5738		}
5739		if (tree.currentStackItem().localName == 'optgroup') {
5740			tree.popElement();
5741		} else {
5742			tree.parseError('unexpected-end-tag-in-select', {name: 'optgroup'});
5743		}
5744	};
5745
5746	modes.inSelect.startTagSelect = function(name) {
5747		tree.parseError("unexpected-select-in-select");
5748		this.endTagSelect('select');
5749	};
5750
5751	modes.inSelect.endTagSelect = function(name) {
5752		if (tree.openElements.inTableScope('select')) {
5753			tree.openElements.popUntilPopped('select');
5754			tree.resetInsertionMode();
5755		} else {
5756			tree.parseError('unexpected-end-tag', {name: name});
5757		}
5758	};
5759
5760	modes.inSelect.startTagInput = function(name, attributes) {
5761		tree.parseError("unexpected-input-in-select");
5762		if (tree.openElements.inSelectScope('select')) {
5763			this.endTagSelect('select');
5764			tree.insertionMode.processStartTag(name, attributes);
5765		}
5766	};
5767
5768	modes.inSelect.startTagScript = function(name, attributes) {
5769		modes.inHead.processStartTag(name, attributes);
5770	};
5771
5772	modes.inSelect.endTagTableElements = function(name) {
5773		tree.parseError('unexpected-end-tag-in-select', {name: name});
5774		if (tree.openElements.inTableScope(name)) {
5775			this.endTagSelect('select');
5776			tree.insertionMode.processEndTag(name);
5777		}
5778	};
5779
5780	modes.inSelect.startTagOther = function(name, attributes) {
5781		tree.parseError("unexpected-start-tag-in-select", {name: name});
5782	};
5783
5784	modes.inSelect.endTagOther = function(name) {
5785		tree.parseError('unexpected-end-tag-in-select', {name: name});
5786	};
5787
5788	modes.inSelectInTable = Object.create(modes.base);
5789
5790	modes.inSelectInTable.start_tag_handlers = {
5791		caption: 'startTagTable',
5792		table: 'startTagTable',
5793		tbody: 'startTagTable',
5794		tfoot: 'startTagTable',
5795		thead: 'startTagTable',

5796		tr: 'startTagTable',
5797		td: 'startTagTable',
5798		th: 'startTagTable',
5799		'-default': 'startTagOther'
5800	};
5801
5802	modes.inSelectInTable.end_tag_handlers = {
5803		caption: 'endTagTable',
5804		table: 'endTagTable',
5805		tbody: 'endTagTable',
5806		tfoot: 'endTagTable',
5807		thead: 'endTagTable',
5808		tr: 'endTagTable',
5809		td: 'endTagTable',
5810		th: 'endTagTable',
5811		'-default': 'endTagOther'
5812	};
5813
5814	modes.inSelectInTable.processCharacters = function(data) {
5815		modes.inSelect.processCharacters(data);
5816	};
5817
5818	modes.inSelectInTable.startTagTable = function(name, attributes) {
5819		tree.parseError("unexpected-table-element-start-tag-in-select-in-table", {name: name});
5820		this.endTagOther("select");
5821		tree.insertionMode.processStartTag(name, attributes);
5822	};
5823
5824	modes.inSelectInTable.startTagOther = function(name, attributes, selfClosing) {
5825		modes.inSelect.processStartTag(name, attributes, selfClosing);
5826	};
5827
5828	modes.inSelectInTable.endTagTable = function(name) {
5829		tree.parseError("unexpected-table-element-end-tag-in-select-in-table", {name: name});
5830		if (tree.openElements.inTableScope(name)) {
5831			this.endTagOther("select");
5832			tree.insertionMode.processEndTag(name);
5833		}
5834	};
5835
5836	modes.inSelectInTable.endTagOther = function(name) {
5837		modes.inSelect.processEndTag(name);
5838	};
5839
5840	modes.inRow = Object.create(modes.base);
5841
5842	modes.inRow.start_tag_handlers = {
5843		html: 'startTagHtml',
5844		td: 'startTagTableCell',
5845		th: 'startTagTableCell',
5846		caption: 'startTagTableOther',
5847		col: 'startTagTableOther',
5848		colgroup: 'startTagTableOther',
5849		tbody: 'startTagTableOther',
5850		tfoot: 'startTagTableOther',
5851		thead: 'startTagTableOther',
5852		tr: 'startTagTableOther',
5853		'-default': 'startTagOther'
5854	};
5855
5856	modes.inRow.end_tag_handlers = {
5857		tr: 'endTagTr',
5858		table: 'endTagTable',
5859		tbody: 'endTagTableRowGroup',
5860		tfoot: 'endTagTableRowGroup',
5861		thead: 'endTagTableRowGroup',
5862		body: 'endTagIgnore',
5863		caption: 'endTagIgnore',
5864		col: 'endTagIgnore',
5865		colgroup: 'endTagIgnore',
5866		html: 'endTagIgnore',
5867		td: 'endTagIgnore',
5868		th: 'endTagIgnore',
5869		'-default': 'endTagOther'
5870	};
5871
5872	modes.inRow.processCharacters = function(data) {
5873		modes.inTable.processCharacters(data);
5874	};
5875
5876	modes.inRow.startTagTableCell = function(name, attributes) {
5877		tree.openElements.popUntilTableRowScopeMarker();
5878		tree.insertElement(name, attributes);
5879		tree.setInsertionMode('inCell');
5880		tree.activeFormattingElements.push(Marker);
5881	};
5882
5883	modes.inRow.startTagTableOther = function(name, attributes) {
5884		var ignoreEndTag = this.ignoreEndTagTr();
5885		this.endTagTr('tr');
5886		if (!ignoreEndTag) tree.insertionMode.processStartTag(name, attributes);
5887	};
5888
5889	modes.inRow.startTagOther = function(name, attributes, selfClosing) {
5890		modes.inTable.processStartTag(name, attributes, selfClosing);
5891	};
5892
5893	modes.inRow.endTagTr = function(name) {
5894		if (this.ignoreEndTagTr()) {
5895			assert.ok(tree.context);
5896			tree.parseError('unexpected-end-tag', {name: name});
5897		} else {
5898			tree.openElements.popUntilTableRowScopeMarker();
5899			tree.popElement();
5900			tree.setInsertionMode('inTableBody');
5901		}
5902	};
5903
5904	modes.inRow.endTagTable = function(name) {
5905		var ignoreEndTag = this.ignoreEndTagTr();
5906		this.endTagTr('tr');
5907		if (!ignoreEndTag) tree.insertionMode.processEndTag(name);
5908	};
5909
5910	modes.inRow.endTagTableRowGroup = function(name) {
5911		if (tree.openElements.inTableScope(name)) {
5912			this.endTagTr('tr');
5913			tree.insertionMode.processEndTag(name);
5914		} else {
5915			tree.parseError('unexpected-end-tag', {name: name});
5916		}
5917	};
5918
5919	modes.inRow.endTagIgnore = function(name) {
5920		tree.parseError("unexpected-end-tag-in-table-row", {name: name});
5921	};
5922
5923	modes.inRow.endTagOther = function(name) {
5924		modes.inTable.processEndTag(name);
5925	};
5926
5927	modes.inRow.ignoreEndTagTr = function() {
5928		return !tree.openElements.inTableScope('tr');
5929	};
5930
5931	modes.afterAfterFrameset = Object.create(modes.base);
5932
5933	modes.afterAfterFrameset.start_tag_handlers = {
5934		html: 'startTagHtml',
5935		noframes: 'startTagNoFrames',
5936		'-default': 'startTagOther'
5937	};
5938
5939	modes.afterAfterFrameset.processEOF = function() {};
5940
5941	modes.afterAfterFrameset.processComment = function(data) {
5942		tree.insertComment(data, tree.document);
5943	};
5944
5945	modes.afterAfterFrameset.processCharacters = function(buffer) {
5946		var characters = buffer.takeRemaining();
5947		var whitespace = "";
5948		for (var i = 0; i < characters.length; i++) {
5949			var ch = characters[i];
5950			if (isWhitespace(ch))
5951				whitespace += ch;
5952		}
5953		if (whitespace) {
5954			tree.reconstructActiveFormattingElements();
5955			tree.insertText(whitespace);
5956		}
5957		if (whitespace.length < characters.length)
5958			tree.parseError('expected-eof-but-got-char');
5959	};
5960
5961	modes.afterAfterFrameset.startTagNoFrames = function(name, attributes) {
5962		modes.inHead.processStartTag(name, attributes);
5963	};
5964
5965	modes.afterAfterFrameset.startTagOther = function(name, attributes, selfClosing) {
5966		tree.parseError('expected-eof-but-got-start-tag', {name: name});
5967	};
5968
5969	modes.afterAfterFrameset.processEndTag = function(name, attributes) {
5970		tree.parseError('expected-eof-but-got-end-tag', {name: name});
5971	};
5972
5973	modes.text = Object.create(modes.base);
5974
5975	modes.text.start_tag_handlers = {
5976		'-default': 'startTagOther'
5977	};
5978
5979	modes.text.end_tag_handlers = {
5980		script: 'endTagScript',
5981		'-default': 'endTagOther'
5982	};
5983
5984	modes.text.processCharacters = function(buffer) {
5985		if (tree.shouldSkipLeadingNewline) {
5986			tree.shouldSkipLeadingNewline = false;

5987			buffer.skipAtMostOneLeadingNewline();
5988		}
5989		var data = buffer.takeRemaining();
5990		if (!data)
5991			return;
5992		tree.insertText(data);
5993	};
5994
5995	modes.text.processEOF = function() {
5996		tree.parseError("expected-named-closing-tag-but-got-eof",
5997			{name: tree.currentStackItem().localName});
5998		tree.openElements.pop();
5999		tree.setInsertionMode(tree.originalInsertionMode);
6000		tree.insertionMode.processEOF();
6001	};
6002
6003	modes.text.startTagOther = function(name) {
6004		throw "Tried to process start tag " + name + " in RCDATA/RAWTEXT mode";
6005	};
6006
6007	modes.text.endTagScript = function(name) {
6008		var node = tree.openElements.pop();
6009		assert.ok(node.localName == 'script');
6010		tree.setInsertionMode(tree.originalInsertionMode);
6011	};
6012
6013	modes.text.endTagOther = function(name) {
6014		tree.openElements.pop();
6015		tree.setInsertionMode(tree.originalInsertionMode);
6016	};
6017}
6018
6019TreeBuilder.prototype.setInsertionMode = function(name) {
6020	this.insertionMode = this.insertionModes[name];
6021	this.insertionModeName = name;
6022};
6023TreeBuilder.prototype.adoptionAgencyEndTag = function(name) {
6024	var outerIterationLimit = 8;
6025	var innerIterationLimit = 3;
6026	var formattingElement;
6027
6028	function isActiveFormattingElement(el) {
6029		return el === formattingElement;
6030	}
6031
6032	var outerLoopCounter = 0;
6033
6034	while (outerLoopCounter++ < outerIterationLimit) {
6035		formattingElement = this.elementInActiveFormattingElements(name);
6036
6037		if (!formattingElement || (this.openElements.contains(formattingElement) && !this.openElements.inScope(formattingElement.localName))) {
6038			this.parseError('adoption-agency-1.1', {name: name});
6039			return false;
6040		}
6041		if (!this.openElements.contains(formattingElement)) {
6042			this.parseError('adoption-agency-1.2', {name: name});
6043			this.removeElementFromActiveFormattingElements(formattingElement);
6044			return true;
6045		}
6046		if (!this.openElements.inScope(formattingElement.localName)) {
6047			this.parseError('adoption-agency-4.4', {name: name});
6048		}
6049
6050		if (formattingElement != this.currentStackItem()) {
6051			this.parseError('adoption-agency-1.3', {name: name});
6052		}
6053		var furthestBlock = this.openElements.furthestBlockForFormattingElement(formattingElement.node);
6054
6055		if (!furthestBlock) {
6056			this.openElements.remove_openElements_until(isActiveFormattingElement);
6057			this.removeElementFromActiveFormattingElements(formattingElement);
6058			return true;
6059		}
6060
6061		var afeIndex = this.openElements.elements.indexOf(formattingElement);
6062		var commonAncestor = this.openElements.item(afeIndex - 1);
6063
6064		var bookmark = this.activeFormattingElements.indexOf(formattingElement);
6065
6066		var node = furthestBlock;
6067		var lastNode = furthestBlock;
6068		var index = this.openElements.elements.indexOf(node);
6069
6070		var innerLoopCounter = 0;
6071		while (innerLoopCounter++ < innerIterationLimit) {
6072			index -= 1;
6073			node = this.openElements.item(index);
6074			if (this.activeFormattingElements.indexOf(node) < 0) {
6075				this.openElements.elements.splice(index, 1);
6076				continue;
6077			}
6078			if (node == formattingElement)
6079				break;
6080
6081			if (lastNode == furthestBlock)
6082				bookmark = this.activeFormattingElements.indexOf(node) + 1;
6083
6084			var clone = this.createElement(node.namespaceURI, node.localName, node.attributes);
6085			var newNode = new StackItem(node.namespaceURI, node.localName, node.attributes, clone);
6086
6087			this.activeFormattingElements[this.activeFormattingElements.indexOf(node)] = newNode;
6088			this.openElements.elements[this.openElements.elements.indexOf(node)] = newNode;
6089
6090			node = newNode;
6091			this.detachFromParent(lastNode.node);
6092			this.attachNode(lastNode.node, node.node);
6093			lastNode = node;
6094		}
6095
6096		this.detachFromParent(lastNode.node);
6097		if (commonAncestor.isFosterParenting()) {
6098			this.insertIntoFosterParent(lastNode.node);
6099		} else {
6100			this.attachNode(lastNode.node, commonAncestor.node);
6101		}
6102
6103		var clone = this.createElement("http://www.w3.org/1999/xhtml", formattingElement.localName, formattingElement.attributes);
6104		var formattingClone = new StackItem(formattingElement.namespaceURI, formattingElement.localName, formattingElement.attributes, clone);
6105
6106		this.reparentChildren(furthestBlock.node, clone);
6107		this.attachNode(clone, furthestBlock.node);
6108
6109		this.removeElementFromActiveFormattingElements(formattingElement);
6110		this.activeFormattingElements.splice(Math.min(bookmark, this.activeFormattingElements.length), 0, formattingClone);
6111
6112		this.openElements.remove(formattingElement);
6113		this.openElements.elements.splice(this.openElements.elements.indexOf(furthestBlock) + 1, 0, formattingClone);
6114	}
6115
6116	return true;
6117};
6118
6119TreeBuilder.prototype.start = function() {
6120	throw "Not mplemented";
6121};
6122
6123TreeBuilder.prototype.startTokenization = function(tokenizer) {
6124	this.tokenizer = tokenizer;
6125	this.compatMode = "no quirks";
6126	this.originalInsertionMode = "initial";
6127	this.framesetOk = true;
6128	this.openElements = new ElementStack();
6129	this.activeFormattingElements = [];
6130	this.start();
6131	if (this.context) {
6132		switch(this.context) {
6133		case 'title':
6134		case 'textarea':
6135			this.tokenizer.setState(Tokenizer.RCDATA);
6136			break;
6137		case 'style':
6138		case 'xmp':
6139		case 'iframe':
6140		case 'noembed':
6141		case 'noframes':
6142			this.tokenizer.setState(Tokenizer.RAWTEXT);
6143			break;
6144		case 'script':
6145			this.tokenizer.setState(Tokenizer.SCRIPT_DATA);
6146			break;
6147		case 'noscript':
6148			if (this.scriptingEnabled)
6149				this.tokenizer.setState(Tokenizer.RAWTEXT);
6150			break;
6151		case 'plaintext':
6152			this.tokenizer.setState(Tokenizer.PLAINTEXT);
6153			break;
6154		}
6155		this.insertHtmlElement();
6156		this.resetInsertionMode();
6157	} else {
6158		this.setInsertionMode('initial');
6159	}
6160};
6161
6162TreeBuilder.prototype.processToken = function(token) {
6163	this.selfClosingFlagAcknowledged = false;

6164
6165	var currentNode = this.openElements.top || null;
6166	var insertionMode;
6167	if (!currentNode || !currentNode.isForeign() ||
6168		(currentNode.isMathMLTextIntegrationPoint() &&
6169			((token.type == 'StartTag' &&
6170					!(token.name in {mglyph:0, malignmark:0})) ||
6171				(token.type === 'Characters'))
6172		) ||
6173		(currentNode.namespaceURI == "http://www.w3.org/1998/Math/MathML" &&
6174			currentNode.localName == 'annotation-xml' &&
6175			token.type == 'StartTag' && token.name == 'svg'
6176		) ||
6177		(currentNode.isHtmlIntegrationPoint() &&
6178			token.type in {StartTag:0, Characters:0}
6179		) ||
6180		token.type == 'EOF'
6181	) {
6182		insertionMode = this.insertionMode;
6183	} else {
6184		insertionMode = this.insertionModes.inForeignContent;
6185	}
6186	switch(token.type) {
6187	case 'Characters':
6188		var buffer = new CharacterBuffer(token.data);
6189		insertionMode.processCharacters(buffer);
6190		break;
6191	case 'Comment':
6192		insertionMode.processComment(token.data);
6193		break;
6194	case 'StartTag':
6195		insertionMode.processStartTag(token.name, token.data, token.selfClosing);
6196		break;
6197	case 'EndTag':
6198		insertionMode.processEndTag(token.name);
6199		break;
6200	case 'Doctype':
6201		insertionMode.processDoctype(token.name, token.publicId, token.systemId, token.forceQuirks);
6202		break;
6203	case 'EOF':
6204		insertionMode.processEOF();
6205		break;
6206	}
6207};
6208TreeBuilder.prototype.isCdataSectionAllowed = function() {
6209	return this.openElements.length > 0 && this.currentStackItem().isForeign();
6210};
6211TreeBuilder.prototype.isSelfClosingFlagAcknowledged = function() {
6212	return this.selfClosingFlagAcknowledged;
6213};
6214
6215TreeBuilder.prototype.createElement = function(namespaceURI, localName, attributes) {
6216	throw new Error("Not implemented");
6217};
6218
6219TreeBuilder.prototype.attachNode = function(child, parent) {
6220	throw new Error("Not implemented");
6221};
6222
6223TreeBuilder.prototype.attachNodeToFosterParent = function(child, table, stackParent) {
6224	throw new Error("Not implemented");
6225};
6226
6227TreeBuilder.prototype.detachFromParent = function(node) {
6228	throw new Error("Not implemented");
6229};
6230
6231TreeBuilder.prototype.addAttributesToElement = function(element, attributes) {
6232	throw new Error("Not implemented");
6233};
6234
6235TreeBuilder.prototype.insertHtmlElement = function(attributes) {
6236	var root = this.createElement("http://www.w3.org/1999/xhtml", 'html', attributes);
6237	this.attachNode(root, this.document);
6238	this.openElements.pushHtmlElement(new StackItem("http://www.w3.org/1999/xhtml", 'html', attributes, root));
6239	return root;
6240};
6241
6242TreeBuilder.prototype.insertHeadElement = function(attributes) {
6243	var element = this.createElement("http://www.w3.org/1999/xhtml", "head", attributes);
6244	this.head = new StackItem("http://www.w3.org/1999/xhtml", "head", attributes, element);
6245	this.attachNode(element, this.openElements.top.node);
6246	this.openElements.pushHeadElement(this.head);
6247	return element;
6248};
6249
6250TreeBuilder.prototype.insertBodyElement = function(attributes) {
6251	var element = this.createElement("http://www.w3.org/1999/xhtml", "body", attributes);
6252	this.attachNode(element, this.openElements.top.node);
6253	this.openElements.pushBodyElement(new StackItem("http://www.w3.org/1999/xhtml", "body", attributes, element));
6254	return element;
6255};
6256
6257TreeBuilder.prototype.insertIntoFosterParent = function(node) {
6258	var tableIndex = this.openElements.findIndex('table');
6259	var tableElement = this.openElements.item(tableIndex).node;
6260	if (tableIndex === 0)
6261		return this.attachNode(node, tableElement);
6262	this.attachNodeToFosterParent(node, tableElement, this.openElements.item(tableIndex - 1).node);
6263};
6264
6265TreeBuilder.prototype.insertElement = function(name, attributes, namespaceURI, selfClosing) {
6266	if (!namespaceURI)
6267		namespaceURI = "http://www.w3.org/1999/xhtml";
6268	var element = this.createElement(namespaceURI, name, attributes);
6269	if (this.shouldFosterParent())
6270		this.insertIntoFosterParent(element);
6271	else
6272		this.attachNode(element, this.openElements.top.node);
6273	if (!selfClosing)
6274		this.openElements.push(new StackItem(namespaceURI, name, attributes, element));
6275};
6276
6277TreeBuilder.prototype.insertFormattingElement = function(name, attributes) {
6278	this.insertElement(name, attributes, "http://www.w3.org/1999/xhtml");
6279	this.appendElementToActiveFormattingElements(this.currentStackItem());
6280};
6281
6282TreeBuilder.prototype.insertSelfClosingElement = function(name, attributes) {
6283	this.selfClosingFlagAcknowledged = true;
6284	this.insertElement(name, attributes, "http://www.w3.org/1999/xhtml", true);
6285};
6286
6287TreeBuilder.prototype.insertForeignElement = function(name, attributes, namespaceURI, selfClosing) {
6288	if (selfClosing)
6289		this.selfClosingFlagAcknowledged = true;
6290	this.insertElement(name, attributes, namespaceURI, selfClosing);
6291};
6292
6293TreeBuilder.prototype.insertComment = function(data, parent) {
6294	throw new Error("Not implemented");
6295};
6296
6297TreeBuilder.prototype.insertDoctype = function(name, publicId, systemId) {
6298	throw new Error("Not implemented");
6299};
6300
6301TreeBuilder.prototype.insertText = function(data) {
6302	throw new Error("Not implemented");
6303};
6304TreeBuilder.prototype.currentStackItem = function() {
6305	return this.openElements.top;
6306};
6307TreeBuilder.prototype.popElement = function() {
6308	return this.openElements.pop();
6309};
6310TreeBuilder.prototype.shouldFosterParent = function() {
6311	return this.redirectAttachToFosterParent && this.currentStackItem().isFosterParenting();
6312};
6313TreeBuilder.prototype.generateImpliedEndTags = function(exclude) {
6314	var name = this.openElements.top.localName;
6315	if (['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'].indexOf(name) != -1 && name != exclude) {
6316		this.popElement();
6317		this.generateImpliedEndTags(exclude);
6318	}
6319};
6320TreeBuilder.prototype.reconstructActiveFormattingElements = function() {
6321	if (this.activeFormattingElements.length === 0)
6322		return;
6323	var i = this.activeFormattingElements.length - 1;
6324	var entry = this.activeFormattingElements[i];
6325	if (entry == Marker || this.openElements.contains(entry))
6326		return;
6327
6328	while (entry != Marker && !this.openElements.contains(entry)) {
6329		i -= 1;
6330		entry = this.activeFormattingElements[i];
6331		if (!entry)
6332			break;
6333	}
6334
6335	while (true) {
6336		i += 1;
6337		entry = this.activeFormattingElements[i];
6338		this.insertElement(entry.localName, entry.attributes);
6339		var element = this.currentStackItem();
6340		this.activeFormattingElements[i] = element;
6341		if (element == this.activeFormattingElements[this.activeFormattingElements.length -1])
6342			break;
6343	}
6344
6345};
6346TreeBuilder.prototype.ensureNoahsArkCondition = function(item) {
6347	var kNoahsArkCapacity = 3;
6348	if (this.activeFormattingElements.length < kNoahsArkCapacity)
6349		return;
6350	var candidates = [];
6351	var newItemAttributeCount = item.attributes.length;
6352	for (var i = this.activeFormattingElements.length - 1; i >= 0; i--) {
6353		var candidate = this.activeFormattingElements[i];
6354		if (candidate === Marker)
6355			break;
6356		if (item.localName !== candidate.localName || item.namespaceURI !== candidate.namespaceURI)
6357			continue;
6358		if (candidate.attributes.length != newItemAttributeCount)
6359			continue;
6360		candidates.push(candidate);
6361	}
6362	if (candidates.length < kNoahsArkCapacity)
6363		return;
6364
6365	var remainingCandidates = [];
6366	var attributes = item.attributes;
6367	for (var i = 0; i < attributes.length; i++) {
6368		var attribute = attributes[i];
6369
6370		for (var j = 0; j < candidates.length; j++) {
6371			var candidate = candidates[j];
6372			var candidateAttribute = getAttribute(candidate, attribute.no

6372deName);
6373			if (candidateAttribute && candidateAttribute.nodeValue === attribute.nodeValue)
6374				remainingCandidates.push(candidate);
6375		}
6376		if (remainingCandidates.length < kNoahsArkCapacity)
6377			return;
6378		candidates = remainingCandidates;
6379		remainingCandidates = [];
6380	}
6381	for (var i = kNoahsArkCapacity - 1; i < candidates.length; i++)
6382		this.removeElementFromActiveFormattingElements(candidates[i]);
6383};
6384TreeBuilder.prototype.appendElementToActiveFormattingElements = function(item) {
6385	this.ensureNoahsArkCondition(item);
6386	this.activeFormattingElements.push(item);
6387};
6388TreeBuilder.prototype.removeElementFromActiveFormattingElements = function(item) {
6389	var index = this.activeFormattingElements.indexOf(item);
6390	if (index >= 0)
6391		this.activeFormattingElements.splice(index, 1);
6392};
6393
6394TreeBuilder.prototype.elementInActiveFormattingElements = function(name) {
6395	var els = this.activeFormattingElements;
6396	for (var i = els.length - 1; i >= 0; i--) {
6397		if (els[i] == Marker) break;
6398		if (els[i].localName == name) return els[i];
6399	}
6400	return false;
6401};
6402
6403TreeBuilder.prototype.clearActiveFormattingElements = function() {
6404    while (!(this.activeFormattingElements.length === 0 || this.activeFormattingElements.pop() == Marker));
6405};
6406
6407TreeBuilder.prototype.reparentChildren = function(oldParent, newParent) {
6408	throw new Error("Not implemented");
6409};
6410TreeBuilder.prototype.setFragmentContext = function(context) {
6411	this.context = context;
6412};
6413TreeBuilder.prototype.parseError = function(code, args) {
6414	if (!this.errorHandler)
6415		return;
6416	var message = formatMessage(messages[code], args);
6417	this.errorHandler.error(message, this.tokenizer._inputStream.location(), code);
6418};
6419TreeBuilder.prototype.resetInsertionMode = function() {
6420	var last = false;
6421	var node = null;
6422	for (var i = this.openElements.length - 1; i >= 0; i--) {
6423		node = this.openElements.item(i);
6424		if (i === 0) {
6425			assert.ok(this.context);
6426			last = true;
6427			node = new StackItem("http://www.w3.org/1999/xhtml", this.context, [], null);
6428		}
6429
6430		if (node.namespaceURI === "http://www.w3.org/1999/xhtml") {
6431			if (node.localName === 'select')
6432				return this.setInsertionMode('inSelect');
6433			if (node.localName === 'td' || node.localName === 'th')
6434				return this.setInsertionMode('inCell');
6435			if (node.localName === 'tr')
6436				return this.setInsertionMode('inRow');
6437			if (node.localName === 'tbody' || node.localName === 'thead' || node.localName === 'tfoot')
6438				return this.setInsertionMode('inTableBody');
6439			if (node.localName === 'caption')
6440				return this.setInsertionMode('inCaption');
6441			if (node.localName === 'colgroup')
6442				return this.setInsertionMode('inColumnGroup');
6443			if (node.localName === 'table')
6444				return this.setInsertionMode('inTable');
6445			if (node.localName === 'head' && !last)
6446				return this.setInsertionMode('inHead');
6447			if (node.localName === 'body')
6448				return this.setInsertionMode('inBody');
6449			if (node.localName === 'frameset')
6450				return this.setInsertionMode('inFrameset');
6451			if (node.localName === 'html')
6452				if (!this.openElements.headElement)
6453					return this.setInsertionMode('beforeHead');
6454				else
6455					return this.setInsertionMode('afterHead');
6456		}
6457
6458		if (last)
6459			return this.setInsertionMode('inBody');
6460	}
6461};
6462
6463TreeBuilder.prototype.processGenericRCDATAStartTag = function(name, attributes) {
6464	this.insertElement(name, attributes);
6465	this.tokenizer.setState(Tokenizer.RCDATA);
6466	this.originalInsertionMode = this.insertionModeName;
6467	this.setInsertionMode('text');
6468};
6469
6470TreeBuilder.prototype.processGenericRawTextStartTag = function(name, attributes) {
6471	this.insertElement(name, attributes);
6472	this.tokenizer.setState(Tokenizer.RAWTEXT);
6473	this.originalInsertionMode = this.insertionModeName;
6474	this.setInsertionMode('text');
6475};
6476
6477TreeBuilder.prototype.adjustMathMLAttributes = function(attributes) {
6478	attributes.forEach(function(a) {
6479		a.namespaceURI = "http://www.w3.org/1998/Math/MathML";
6480		if (constants.MATHMLAttributeMap[a.nodeName])
6481			a.nodeName = constants.MATHMLAttributeMap[a.nodeName];
6482	});
6483	return attributes;
6484};
6485
6486TreeBuilder.prototype.adjustSVGTagNameCase = function(name) {
6487	return constants.SVGTagMap[name] || name;
6488};
6489
6490TreeBuilder.prototype.adjustSVGAttributes = function(attributes) {

6491	attributes.forEach(function(a) {
6492		a.namespaceURI = "http://www.w3.org/2000/svg";
6493		if (constants.SVGAttributeMap[a.nodeName])
6494			a.nodeName = constants.SVGAttributeMap[a.nodeName];
6495	});
6496	return attributes;
6497};
6498
6499TreeBuilder.prototype.adjustForeignAttributes = function(attributes) {
6500	for (var i = 0; i < attributes.length; i++) {
6501		var attribute = attributes[i];
6502		var adjusted = constants.ForeignAttributeMap[attribute.nodeName];
6503		if (adjusted) {
6504			attribute.nodeName = adjusted.localName;
6505			attribute.prefix = adjusted.prefix;
6506			attribute.namespaceURI = adjusted.namespaceURI;
6507		}
6508	}
6509	return attributes;
6510};
6511
6512function formatMessage(format, args) {
6513	return format.replace(new RegExp('{[0-9a-z-]+}', 'gi'), function(match) {
6514		return args[match.slice(1, -1)] || match;
6515	});
6516}
6517
6518exports.TreeBuilder = TreeBuilder;
6519
6520},
6521{"./ElementStack":1,"./StackItem":4,"./Tokenizer":5,"./constants":7,"./messages.json":8,"assert":13,"events":16}],
65227:[function(_dereq_,module,exports){
6523exports.SVGTagMap = {
6524	"altglyph": "altGlyph",
6525	"altglyphdef": "altGlyphDef",
6526	"altglyphitem": "altGlyphItem",
6527	"animatecolor": "animateColor",
6528	"animatemotion": "animateMotion",
6529	"animatetransform": "animateTransform",
6530	"clippath": "clipPath",
6531	"feblend": "feBlend",
6532	"fecolormatrix": "feColorMatrix",
6533	"fecomponenttransfer": "feComponentTransfer",
6534	"fecomposite": "feComposite",
6535	"feconvolvematrix": "feConvolveMatrix",
6536	"fediffuselighting": "feDiffuseLighting",
6537	"fedisplacementmap": "feDisplacementMap",
6538	"fedistantlight": "feDistantLight",
6539	"feflood": "feFlood",
6540	"fefunca": "feFuncA",
6541	"fefuncb": "feFuncB",
6542	"fefuncg": "feFuncG",
6543	"fefuncr": "feFuncR",
6544	"fegaussianblur": "feGaussianBlur",
6545	"feimage": "feImage",
6546	"femerge": "feMerge",
6547	"femergenode": "feMergeNode",
6548	"femorphology": "feMorphology",
6549	"feoffset": "feOffset",
6550	"fepointlight": "fePointLight",
6551	"fespecularlighting": "feSpecularLighting",
6552	"fespotlight": "feSpotLight",
6553	"fetile": "feTile",
6554	"feturbulence": "feTurbulence",
6555	"foreignobject": "foreignObject",
6556	"glyphref": "glyphRef",
6557	"lineargradient": "linearGradient",
6558	"radialgradient": "radialGradient",
6559	"textpath": "textPath"
6560};
6561
6562exports.MATHMLAttributeMap = {
6563	definitionurl: 'definitionURL'
6564};
6565
6566exports.SVGAttributeMap = {
6567	attributename:	'attributeName',
6568	attributetype:	'attributeType',
6569	basefrequency:	'baseFrequency',
6570	baseprofile:	'baseProfile',
6571	calcmode:	'calcMode',
6572	clippathunits:	'clipPathUnits',
6573	contentscripttype:	'contentScriptType',
6574	contentstyletype:	'contentStyleType',
6575	diffuseconstant:	'diffuseConstant',
6576	edgemode:	'edgeMode',
6577	externalresourcesrequired:	'externalResourcesRequired',
6578	filterres:	'filterRes',
6579	filterunits:	'filterUnits',
6580	glyphref:	'glyphRef',
6581	gradienttransform:	'gradientTransform',
6582	gradientunits:	'gradientUnits',
6583	kernelmatrix:	'kernelMatrix',
6584	kernelunitlength:	'kernelUnitLength',
6585	keypoints:	'keyPoints',
6586	keysplines:	'keySplines',
6587	keytimes:	'keyTimes',
6588	lengthadjust:	'lengthAdjust',
6589	limitingconeangle:	'limitingConeAngle',
6590	markerheight:	'markerHeight',
6591	markerunits:	'markerUnits',
6592	markerwidth:	'markerWidth',
6593	maskcontentunits:	'maskContentUnits',
6594	maskunits:	'maskUnits',
6595	numoctaves:	'numOctaves',
6596	pathlength:	'pathLength',
6597	patterncontentunits:	'patternContentUnits',
6598	patterntransform:	'patternTransform',
6599	patternunits:	'patternUnits',
6600	pointsatx:	'pointsAtX',
6601	pointsaty:	'pointsAtY',
6602	pointsatz:	'pointsAtZ',
6603	preservealpha:	'preserveAlpha',
6604	preserveaspectratio:	'preserveAspectRatio',
6605	primitiveunits:	'primitiveUnits',
6606	refx:	'refX',
6607	refy:	'refY',
6608	repeatcount:	'repeatCount',
6609	repeatdur:	'repeatDur',
6610	requiredextensions:	'requiredExtensions',
6611	requiredfeatures:	'requiredFeatures',
6612	specularconstant:	'specularConstant',
6613	specularexponent:	'specularExponent',
6614	spreadmethod:	'spreadMethod',
6615	startoffset:	'startOffset',
6616	stddeviation:	'stdDeviation',
6617	stitchtiles:	'stitchTiles',
6618	surfacescale:	'surfaceScale',
6619	systemlanguage:	'systemLanguage',
6620	tablevalues:	'tableValues',
6621	targetx:	'targetX',
6622	targety:	'targetY',
6623	textlength:	'textLength',
6624	viewbox:	'viewBox',
6625	viewtarget:	'viewTarget',
6626	xchannelselector:	'xChannelSelector',
6627	ychannelselector:	'yChannelSelector',
6628	zoomandpan:	'zoomAndPan'
6629};
6630
6631exports.ForeignAttributeMap = {
6632	"xlink:actuate": {prefix: "xlink", localName: "actuate", namespaceURI: "http://www.w3.org/1999/xlink"},
6633	"xlink:arcrole": {prefix: "xlink", localName: "arcrole", namespaceURI: "http://www.w3.org/1999/xlink"},
6634	"xlink:href": {prefix: "xlink", localName: "href", namespaceURI: "http://www.w3.org/1999/xlink"},
6635	"xlink:role": {prefix: "xlink", localName: "role", namespaceURI: "http://www.w3.org/1999/xlink"},
6636	"xlink:show": {prefix: "xlink", localName: "show", namespaceURI: "http://www.w3.org/1999/xlink"},
6637	"xlink:title": {prefix: "xlink", localName: "title", namespaceURI: "http://www.w3.org/1999/xlink"},
6638	"xlink:type": {prefix: "xlink", localName: "title", namespaceURI: "http://www.w3.org/1999/xlink"},
6639	"xml:base": {prefix: "xml", localName: "base", namespaceURI: "http://www.w3.org/XML/1998/namespace"},
6640	"xml:lang": {prefix: "xml", localName: "lang", namespaceURI: "http://www.w3.org/XML/1998/namespace"},
6641	"xml:space": {prefix: "xml", localName: "space", namespaceURI: "http://www.w3.org/XML/1998/namespace"},
6642	"xmlns": {prefix: null, localName: "xmlns", namespaceURI: "http://www.w3.org/2000/xmlns/"},
6643	"xmlns:xlink": {prefix: "xmlns", localName: "xlink", namespaceURI: "http://www.w3.org/2000/xmlns/"},
6644};
6645},
6646{}],
66478:[function(_dereq_,module,exports){
6648module.exports={
6649	"null-character":
6650		"Null character in input stream, replaced with U+FFFD.",

6651	"invalid-codepoint":
6652		"Invalid codepoint in stream",
6653	"incorrectly-placed-solidus":
6654		"Solidus (/) incorrectly placed in tag.",
6655	"incorrect-cr-newline-entity":
6656		"Incorrect CR newline entity, replaced with LF.",
6657	"illegal-windows-1252-entity":
6658		"Entity used with illegal number (windows-1252 reference).",
6659	"cant-convert-numeric-entity":
6660		"Numeric entity couldn't be converted to character (codepoint U+{charAsInt}).",
6661	"invalid-numeric-entity-replaced":
6662		"Numeric entity represents an illegal codepoint. Expanded to the C1 controls range.",
6663	"numeric-entity-without-semicolon":
6664		"Numeric entity didn't end with ';'.",
6665	"expected-numeric-entity-but-got-eof":
6666		"Numeric entity expected. Got end of file instead.",
6667	"expected-numeric-entity":
6668		"Numeric entity expected but none found.",
6669	"named-entity-without-semicolon":
6670		"Named entity didn't end with ';'.",
6671	"expected-named-entity":
6672		"Named entity expected. Got none.",
6673	"attributes-in-end-tag":
6674		"End tag contains unexpected attributes.",
6675	"self-closing-flag-on-end-tag":
6676		"End tag contains unexpected self-closing flag.",
6677	"bare-less-than-sign-at-eof":
6678		"End of file after <.",
6679	"expected-tag-name-but-got-right-bracket":
6680		"Expected tag name. Got '>' instead.",
6681	"expected-tag-name-but-got-question-mark":
6682		"Expected tag name. Got '?' instead. (HTML doesn't support processing instructions.)",
6683	"expected-tag-name":
6684		"Expected tag name. Got something else instead.",
6685	"expected-closing-tag-but-got-right-bracket":
6686		"Expected closing tag. Got '>' instead. Ignoring '</>'.",
6687	"expected-closing-tag-but-got-eof":
6688		"Expected closing tag. Unexpected end of file.",
6689	"expected-closing-tag-but-got-char":
6690		"Expected closing tag. Unexpected character '{data}' found.",
6691	"eof-in-tag-name":
6692		"Unexpected end of file in the tag name.",
6693	"expected-attribute-name-but-got-eof":
6694		"Unexpected end of file. Expected attribute name instead.",
6695	"eof-in-attribute-name":
6696		"Unexpected end of file in attribute name.",
6697	"invalid-character-in-attribute-name":
6698		"Invalid character in attribute name.",
6699	"duplicate-attribute":
6700		"Dropped duplicate attribute '{name}' on tag.",
6701	"expected-end-of-tag-but-got-eof":
6702		"Unexpected end of file. Expected = or end of tag.",
6703	"expected-attribute-value-but-got-eof":
6704		"Unexpected end of file. Expected attribute value.",
6705	"expected-attribute-value-but-got-right-bracket":
6706		"Expected attribute value. Got '>' instead.",
6707	"unexpected-character-in-unquoted-attribute-value":
6708		"Unexpected character in unquoted attribute",
6709	"invalid-character-after-attribute-name":
6710		"Unexpected character after attribute name.",
6711	"unexpected-character-after-attribute-value":
6712		"Unexpected character after attribute value.",
6713	"eof-in-attribute-value-double-quote":
6714		"Unexpected end of file in attribute value (\").",
6715	"eof-in-attribute-value-single-quote":
6716		"Unexpected end of file in attribute value (').",
6717	"eof-in-attribute-value-no-quotes":
6718		"Unexpected end of file in attribute value.",
6719	"eof-after-attribute-value":
6720		"Unexpected end of file after attribute value.",
6721	"unexpected-eof-after-solidus-in-tag":
6722		"Unexpected end of file in tag. Expected >.",
6723	"unexpected-character-after-solidus-in-tag":
6724		"Unexpected character after / in tag. Expected >.",
6725	"expected-dashes-or-doctype":
6726		"Expected '--' or 'DOCTYPE'. Not found.",
6727	"unexpected-bang-after-double-dash-in-comment":
6728		"Unexpected ! after -- in comment.",
6729	"incorrect-comment":
6730		"Incorrect comment.",
6731	"eof-in-comment":
6732		"Unexpected end of file in comment.",
6733	"eof-in-comment-end-dash":
6734		"Unexpected end of file in comment (-).",
6735	"unexpected-dash-after-double-dash-in-comment":
6736		"Unexpected '-' after '--' found in comment.",
6737	"eof-in-comment-double-dash":
6738		"Unexpected end of file in comment (--).",
6739	"eof-in-comment-end-bang-state":
6740		"Unexpected end of file in comment.",
6741	"unexpected-char-in-comment":
6742		"Unexpected character in comment found.",
6743	"need-space-after-doctype":
6744		"No space after literal string 'DOCTYPE'.",
6745	"expected-doctype-name-but-got-right-bracket":
6746		"Unexpected > character. Expected DOCTYPE name.",
6747	"expected-doctype-name-but-got-eof":
6748		"Unexpected end of file. Expected DOCTYPE name.",
6749	"eof-in-doctype-name":
6750		"Unexpected end of file in DOCTYPE name.",
6751	"eof-in-doctype":
6752		"Unexpected end of file in DOCTYPE.",
6753	"expected-space-or-right-bracket-in-doctype":
6754		"Expected space or '>'. Got '{data}'.",
6755	"unexpected-end-of-doctype":
6756		"Unexpected end of DOCTYPE.",
6757	"unexpected-char-in-doctype":
6758		"Unexpected character in DOCTYPE.",
6759	"eof-in-bogus-doctype":
6760		"Unexpected end of file in bogus doctype.",
6761	"eof-in-innerhtml":
6762		"Unexpected EOF in inner html mode.",
6763	"unexpected-doctype":
6764		"Unexpected DOCTYPE. Ignored.",
6765	"non-html-root":
6766		"html needs to be the first start tag.",
6767	"expected-doctype-but-got-eof":
6768		"Unexpected End of file. Expected DOCTYPE.",
6769	"unknown-doctype":
6770		"Erroneous DOCTYPE. Expected <!DOCTYPE html>.",
6771	"quirky-doctype":
6772		"Quirky doctype. Expected <!DOCTYPE html>.",
6773	"almost-standards-doctype":
6774		"Almost standards mode doctype. Expected <!DOCTYPE html>.",
6775	"obsolete-doctype":
6776		"Obsolete doctype. Expected <!DOCTYPE html>.",
6777	"expected-doctype-but-got-chars":
6778		"Non-space characters found without seeing a doctype first. Expected e.g. <!DOCTYPE html>.",
6779	"expected-doctype-but-got-start-tag":
6780		"Start tag seen without seeing a doctype first. Expected e.g. <!DOCTYPE html>.",
6781	"expected-doctype-but-got-end-tag":
6782		"End tag seen without seeing a doctype first. Expected e.g. <!DOCTYPE html>.",
6783	"end-tag-after-implied-root":
6784		"Unexpected end tag ({name}) after the (implied) root element.",
6785	"expected-named-closing-tag-but-got-eof":
6786		"Unexpected end of file. Expected end tag ({name}).",
6787	"two-heads-are-not-better-than-one":

6788		"Unexpected start tag head in existing head. Ignored.",
6789	"unexpected-end-tag":
6790		"Unexpected end tag ({name}). Ignored.",
6791	"unexpected-implied-end-tag":
6792		"End tag {name} implied, but there were open elements.",
6793	"unexpected-start-tag-out-of-my-head":
6794		"Unexpected start tag ({name}) that can be in head. Moved.",
6795	"unexpected-start-tag":
6796		"Unexpected start tag ({name}).",
6797	"missing-end-tag":
6798		"Missing end tag ({name}).",
6799	"missing-end-tags":
6800		"Missing end tags ({name}).",
6801	"unexpected-start-tag-implies-end-tag":
6802		"Unexpected start tag ({startName}) implies end tag ({endName}).",
6803	"unexpected-start-tag-treated-as":
6804		"Unexpected start tag ({originalName}). Treated as {newName}.",
6805	"deprecated-tag":
6806		"Unexpected start tag {name}. Don't use it!",
6807	"unexpected-start-tag-ignored":
6808		"Unexpected start tag {name}. Ignored.",
6809	"expected-one-end-tag-but-got-another":
6810		"Unexpected end tag ({gotName}). Missing end tag ({expectedName}).",
6811	"end-tag-too-early":
6812		"End tag ({name}) seen too early. Expected other end tag.",
6813	"end-tag-too-early-named":
6814		"Unexpected end tag ({gotName}). Expected end tag ({expectedName}.",
6815	"end-tag-too-early-ignored":
6816		"End tag ({name}) seen too early. Ignored.",
6817	"adoption-agency-1.1":
6818		"End tag ({name}) violates step 1, paragraph 1 of the adoption agency algorithm.",
6819	"adoption-agency-1.2":
6820		"End tag ({name}) violates step 1, paragraph 2 of the adoption agency algorithm.",
6821	"adoption-agency-1.3":
6822		"End tag ({name}) violates step 1, paragraph 3 of the adoption agency algorithm.",
6823	"adoption-agency-4.4":
6824		"End tag ({name}) violates step 4, paragraph 4 of the adoption agency algorithm.",
6825	"unexpected-end-tag-treated-as":
6826		"Unexpected end tag ({originalName}). Treated as {newName}.",
6827	"no-end-tag":
6828		"This element ({name}) has no end tag.",
6829	"unexpected-implied-end-tag-in-table":
6830		"Unexpected implied end tag ({name}) in the table phase.",
6831	"unexpected-implied-end-tag-in-table-body":
6832		"Unexpected implied end tag ({name}) in the table body phase.",
6833	"unexpected-char-implies-table-voodoo":
6834		"Unexpected non-space characters in table context caused voodoo mode.",
6835	"unexpected-hidden-input-in-table":
6836		"Unexpected input with type hidden in table context.",
6837	"unexpected-form-in-table":
6838		"Unexpected form in table context.",
6839	"unexpected-start-tag-implies-table-voodoo":
6840		"Unexpected start tag ({name}) in table context caused voodoo mode.",
6841	"unexpected-end-tag-implies-table-voodoo":
6842		"Unexpected end tag ({name}) in table context caused voodoo mode.",
6843	"unexpected-cell-in-table-body":
6844		"Unexpected table cell start tag ({name}) in the table body phase.",
6845	"unexpected-cell-end-tag":
6846		"Got table cell end tag ({name}) while required end tags are missing.",
6847	"unexpected-end-tag-in-table-body":
6848		"Unexpected end tag ({name}) in the table body phase. Ignored.",
6849	"unexpected-implied-end-tag-in-table-row":
6850		"Unexpected implied end tag ({name}) in the table row phase.",
6851	"unexpected-end-tag-in-table-row":
6852		"Unexpected end tag ({name}) in the table row phase. Ignored.",
6853	"unexpected-select-in-select":
6854		"Unexpected select start tag in the select phase treated as select end tag.",
6855	"unexpected-input-in-select":
6856		"Unexpected input start tag in the select phase.",
6857	"unexpected-start-tag-in-select":
6858		"Unexpected start tag token ({name}) in the select phase. Ignored.",
6859	"unexpected-end-tag-in-select":
6860		"Unexpected end tag ({name}) in the select phase. Ignored.",
6861	"unexpected-table-element-start-tag-in-select-in-table":
6862		"Unexpected table element start tag ({name}) in the select in table phase.",
6863	"unexpected-table-element-end-tag-in-select-in-table":
6864		"Unexpected table element end tag ({name}) in the select in table phase.",
6865	"unexpected-char-after-body":
6866		"Unexpected non-space characters in the after body phase.",
6867	"unexpected-start-tag-after-body":
6868		"Unexpected start tag token ({name}) in the after body phase.",
6869	"unexpected-end-tag-after-body":
6870		"Unexpected end tag token ({name}) in the after body phase.",
6871	"unexpected-char-in-frameset":
6872		"Unepxected characters in the frameset phase. Characters ignored.",
6873	"unexpected-start-tag-in-frameset":

6874		"Unexpected start tag token ({name}) in the frameset phase. Ignored.",
6875	"unexpected-frameset-in-frameset-innerhtml":
6876		"Unexpected end tag token (frameset in the frameset phase (innerHTML).",
6877	"unexpected-end-tag-in-frameset":
6878		"Unexpected end tag token ({name}) in the frameset phase. Ignored.",
6879	"unexpected-char-after-frameset":
6880		"Unexpected non-space characters in the after frameset phase. Ignored.",
6881	"unexpected-start-tag-after-frameset":
6882		"Unexpected start tag ({name}) in the after frameset phase. Ignored.",
6883	"unexpected-end-tag-after-frameset":
6884		"Unexpected end tag ({name}) in the after frameset phase. Ignored.",
6885	"expected-eof-but-got-char":
6886		"Unexpected non-space characters. Expected end of file.",
6887	"expected-eof-but-got-start-tag":
6888		"Unexpected start tag ({name}). Expected end of file.",
6889	"expected-eof-but-got-end-tag":
6890		"Unexpected end tag ({name}). Expected end of file.",
6891	"unexpected-end-table-in-caption":
6892		"Unexpected end table tag in caption. Generates implied end caption.",
6893	"end-html-in-innerhtml": 
6894		"Unexpected html end tag in inner html mode.",
6895	"eof-in-table":
6896		"Unexpected end of file. Expected table content.",
6897	"eof-in-script":
6898		"Unexpected end of file. Expected script content.",
6899	"non-void-element-with-trailing-solidus":
6900		"Trailing solidus not allowed on element {name}.",
6901	"unexpected-html-element-in-foreign-content":
6902		"HTML start tag \"{name}\" in a foreign namespace context.",
6903	"unexpected-start-tag-in-table":
6904		"Unexpected {name}. Expected table content."
6905}
6906},
6907{}],
69089:[function(_dereq_,module,exports){
6909var SAXTreeBuilder = _dereq_('./SAXTreeBuilder').SAXTreeBuilder;
6910var Tokenizer = _dereq_('../Tokenizer').Tokenizer;
6911var TreeParser = _dereq_('./TreeParser').TreeParser;
6912
6913function SAXParser() {
6914	this.contentHandler = null;
6915	this._errorHandler = null;
6916	this._treeBuilder = new SAXTreeBuilder();
6917	this._tokenizer = new Tokenizer(this._treeBuilder);
6918	this._scriptingEnabled = false;
6919}
6920
6921SAXParser.prototype.parse = function(source) {
6922	this._tokenizer.tokenize(source);
6923	var document = this._treeBuilder.document;
6924	if (document) {
6925		new TreeParser(this.contentHandler).parse(document);
6926	}
6927};
6928
6929SAXParser.prototype.parseFragment = function(source, context) {
6930	this._treeBuilder.setFragmentContext(context);
6931	this._tokenizer.tokenize(source);
6932	var fragment = this._treeBuilder.getFragment();
6933	if (fragment) {
6934		new TreeParser(this.contentHandler).parse(fragment);
6935	}
6936};
6937
6938Object.defineProperty(SAXParser.prototype, 'scriptingEnabled', {
6939	get: function() {
6940		return this._scriptingEnabled;
6941	},
6942	set: function(value) {
6943		this._scriptingEnabled = value;
6944		this._treeBuilder.scriptingEnabled = value;
6945	}
6946});
6947
6948Object.defineProperty(SAXParser.prototype, 'errorHandler', {
6949	get: function() {
6950		return this._errorHandler;
6951	},
6952	set: function(value) {
6953		this._errorHandler = value;
6954		this._treeBuilder.errorHandler = value;
6955	}
6956});
6957
6958exports.SAXParser = SAXParser;
6959
6960},
6961{"../Tokenizer":5,"./SAXTreeBuilder":10,"./TreeParser":11}],
696210:[function(_dereq_,module,exports){
6963var util = _dereq_('util');
6964var TreeBuilder = _dereq_('../TreeBuilder').TreeBuilder;
6965
6966function SAXTreeBuilder() {
6967	TreeBuilder.call(this);
6968}
6969
6970util.inherits(SAXTreeBuilder, TreeBuilder);
6971
6972SAXTreeBuilder.prototype.start = function(tokenizer) {
6973	this.document = new Document(this.tokenizer);
6974};
6975
6976SAXTreeBuilder.prototype.end = function() {
6977	this.document.endLocator = this.tokenizer;
6978};
6979
6980SAXTreeBuilder.prototype.insertDoctype = function(name, publicId, systemId) {
6981	var doctype = new DTD(this.tokenizer, name, publicId, systemId);
6982	doctype.endLocator = this.tokenizer;
6983	this.document.appendChild(doctype);
6984};
6985
6986SAXTreeBuilder.prototype.createElement = function(namespaceURI, localName, attributes) {
6987	var element = new Element(this.tokenizer, namespaceURI, localName, localName, attributes || []);
6988	return element;
6989};
6990
6991SAXTreeBuilder.prototype.insertComment = function(data, parent) {
6992	if (!parent)
6993		parent = this.currentStackItem();
6994	var comment = new Comment(this.tokenizer, data);
6995	parent.appendChild(comment);
6996};
6997
6998SAXTreeBuilder.prototype.appendCharacters = function(parent, data) {
6999	var text = new Characters(this.tokenizer, data);
7000	parent.appendChild(text);
7001};
7002
7003SAXTreeBuilder.prototype.insertText = function(data) {
7004	if (this.redirectAttachToFosterParent && this.openElements.top.isFosterParenting()) {
7005		var tableIndex = this.openElements.findIndex('table');
7006		var tableItem = this.openElements.item(tableIndex);
7007		var table = tableItem.node;

7008		if (tableIndex === 0) {
7009			return this.appendCharacters(table, data);
7010		}
7011		var text = new Characters(this.tokenizer, data);
7012		var parent = table.parentNode;
7013		if (parent) {
7014			parent.insertBetween(text, table.previousSibling, table);
7015			return;
7016		}
7017		var stackParent = this.openElements.item(tableIndex - 1).node;
7018		stackParent.appendChild(text);
7019		return;
7020	}
7021	this.appendCharacters(this.currentStackItem().node, data);
7022};
7023
7024SAXTreeBuilder.prototype.attachNode = function(node, parent) {
7025	parent.appendChild(node);
7026};
7027
7028SAXTreeBuilder.prototype.attachNodeToFosterParent = function(child, table, stackParent) {
7029	var parent = table.parentNode;
7030	if (parent)
7031		parent.insertBetween(child, table.previousSibling, table);
7032	else
7033		stackParent.appendChild(child);
7034};
7035
7036SAXTreeBuilder.prototype.detachFromParent = function(element) {
7037	element.detach();
7038};
7039
7040SAXTreeBuilder.prototype.reparentChildren = function(oldParent, newParent) {
7041	newParent.appendChildren(oldParent.firstChild);
7042};
7043
7044SAXTreeBuilder.prototype.getFragment = function() {
7045	var fragment = new DocumentFragment();
7046	this.reparentChildren(this.openElements.rootNode, fragment);
7047	return fragment;
7048};
7049
7050function getAttribute(node, name) {
7051	for (var i = 0; i < node.attributes.length; i++) {
7052		var attribute = node.attributes[i];
7053		if (attribute.nodeName === name)
7054			return attribute.nodeValue;
7055	}
7056}
7057
7058SAXTreeBuilder.prototype.addAttributesToElement = function(element, attributes) {
7059	for (var i = 0; i < attributes.length; i++) {
7060		var attribute = attributes[i];
7061		if (!getAttribute(element, attribute.nodeName))
7062			element.attributes.push(attribute);
7063	}
7064};
7065
7066var NodeType = {
7067	CDATA: 1,
7068	CHARACTERS: 2,
7069	COMMENT: 3,
7070	DOCUMENT: 4,
7071	DOCUMENT_FRAGMENT: 5,
7072	DTD: 6,
7073	ELEMENT: 7,
7074	ENTITY: 8,
7075	IGNORABLE_WHITESPACE: 9,
7076	PROCESSING_INSTRUCTION: 10,
7077	SKIPPED_ENTITY: 11
7078};
7079function Node(locator) {
7080	if (!locator) {
7081		this.columnNumber = -1;
7082		this.lineNumber = -1;
7083	} else {
7084		this.columnNumber = locator.columnNumber;
7085		this.lineNumber = locator.lineNumber;
7086	}
7087	this.parentNode = null;
7088	this.nextSibling = null;
7089	this.firstChild = null;
7090}
7091Node.prototype.visit = function(treeParser) {
7092	throw new Error("Not Implemented");
7093};
7094Node.prototype.revisit = function(treeParser) {
7095	return;
7096};
7097Node.prototype.detach = function() {
7098	if (this.parentNode !== null) {
7099		this.parentNode.removeChild(this);
7100		this.parentNode = null;
7101	}
7102};
7103
7104Object.defineProperty(Node.prototype, 'previousSibling', {
7105	get: function() {
7106		var prev = null;
7107		var next = this.parentNode.firstChild;
7108		for(;;) {
7109			if (this == next) {
7110				return prev;
7111			}
7112			prev = next;
7113			next = next.nextSibling;
7114		}
7115	}
7116});
7117
7118
7119function ParentNode(locator) {
7120	Node.call(this, locator);
7121	this.lastChild = null;
7122	this._endLocator = null;
7123}
7124
7125ParentNode.prototype = Object.create(Node.prototype);
7126ParentNode.prototype.insertBefore = function(child, sibling) {
7127	if (!sibling) {
7128		return this.appendChild(child);
7129	}
7130	child.detach();
7131	child.parentNode = this;
7132	if (this.firstChild == sibling) {
7133		child.nextSibling = sibling;
7134		this.firstChild = child;
7135	} else {
7136		var prev = this.firstChild;
7137		var next = this.firstChild.nextSibling;
7138		while (next != sibling) {
7139			prev = next;
7140			next = next.nextSibling;
7141		}
7142		prev.nextSibling = child;
7143		child.nextSibling = next;
7144	}
7145	return child;
7146};
7147
7148ParentNode.prototype.insertBetween = function(child, prev, next) {
7149	if (!next) {
7150		return this.appendChild(child);
7151	}
7152	child.detach();
7153	child.parentNode = this;
7154	child.nextSibling = next;
7155	if (!prev) {
7156		firstChild = child;
7157	} else {
7158		prev.nextSibling = child;
7159	}
7160	return child;
7161};
7162ParentNode.prototype.appendChild = function(child) {
7163	child.detach();
7164	child.parentNode = this;
7165	if (!this.firstChild) {
7166		this.firstChild = child;
7167	} else {
7168		this.lastChild.nextSibling = child;
7169	}
7170	this.lastChild = child;
7171	return child;
7172};
7173ParentNode.prototype.appendChildren = function(parent) {
7174	var child = parent.firstChild;
7175	if (!child) {
7176		return;
7177	}
7178	var another = parent;
7179	if (!this.firstChild) {
7180		this.firstChild = child;
7181	} else {
7182		this.lastChild.nextSibling = child;
7183	}
7184	this.lastChild = another.lastChild;
7185	do {
7186		child.parentNode = this;
7187	} while ((child = child.nextSibling));
7188	another.firstChild = null;
7189	another.lastChild = null;
7190};
7191ParentNode.prototype.removeChild = function(node) {
7192	if (this.firstChild == node) {
7193		this.firstChild = node.nextSibling;
7194		if (this.lastChild == node) {
7195			this.lastChild = null;
7196		}
7197	} else {
7198		var prev = this.firstChild;
7199		var next = this.firstChild.nextSibling;
7200		while (next != node) {
7201			prev = next;
7202			next = next.nextSibling;
7203		}
7204		prev.nextSibling = node.nextSibling;
7205		if (this.lastChild == node) {
7206			this.lastChild = prev;
7207		}
7208	}
7209	node.parentNode = null;
7210	return node;
7211};
7212
7213Object.defineProperty(ParentNode.prototype, 'endLocator', {
7214	get: function() {
7215		return this._endLocator;
7216	},

7217	set: function(endLocator) {
7218		this._endLocator = {
7219			lineNumber: endLocator.lineNumber,
7220			columnNumber: endLocator.columnNumber
7221		};
7222	}
7223});
7224function Document (locator) {
7225	ParentNode.call(this, locator);
7226	this.nodeType = NodeType.DOCUMENT;
7227}
7228
7229Document.prototype = Object.create(ParentNode.prototype);
7230Document.prototype.visit = function(treeParser) {
7231	treeParser.startDocument(this);
7232};
7233Document.prototype.revisit = function(treeParser) {
7234	treeParser.endDocument(this.endLocator);
7235};
7236function DocumentFragment() {
7237	ParentNode.call(this, new Locator());
7238	this.nodeType = NodeType.DOCUMENT_FRAGMENT;
7239}
7240
7241DocumentFragment.prototype = Object.create(ParentNode.prototype);
7242DocumentFragment.prototype.visit = function(treeParser) {
7243};
7244function Element(locator, uri, localName, qName, atts, prefixMappings) {
7245	ParentNode.call(this, locator);
7246	this.uri = uri;
7247	this.localName = localName;
7248	this.qName = qName;
7249	this.attributes = atts;
7250	this.prefixMappings = prefixMappings;
7251	this.nodeType = NodeType.ELEMENT;
7252}
7253
7254Element.prototype = Object.create(ParentNode.prototype);
7255Element.prototype.visit = function(treeParser) {
7256	if (this.prefixMappings) {
7257		for (var key in prefixMappings) {
7258			var mapping = prefixMappings[key];
7259			treeParser.startPrefixMapping(mapping.getPrefix(),
7260					mapping.getUri(), this);
7261		}
7262	}
7263	treeParser.startElement(this.uri, this.localName, this.qName, this.attributes, this);
7264};
7265Element.prototype.revisit = function(treeParser) {
7266	treeParser.endElement(this.uri, this.localName, this.qName, this.endLocator);
7267	if (this.prefixMappings) {
7268		for (var key in prefixMappings) {
7269			var mapping = prefixMappings[key];
7270			treeParser.endPrefixMapping(mapping.getPrefix(), this.endLocator);
7271		}
7272	}
7273};
7274function Characters(locator, data){
7275	Node.call(this, locator);
7276	this.data = data;
7277	this.nodeType = NodeType.CHARACTERS;
7278}
7279
7280Characters.prototype = Object.create(Node.prototype);
7281Characters.prototype.visit = function (treeParser) {
7282	treeParser.characters(this.data, 0, this.data.length, this);
7283};
7284function IgnorableWhitespace(locator, data) {
7285	Node.call(this, locator);
7286	this.data = data;
7287	this.nodeType = NodeType.IGNORABLE_WHITESPACE;
7288}
7289
7290IgnorableWhitespace.prototype = Object.create(Node.prototype);
7291IgnorableWhitespace.prototype.visit = function(treeParser) {
7292	treeParser.ignorableWhitespace(this.data, 0, this.data.length, this);
7293};
7294function Comment(locator, data) {
7295	Node.call(this, locator);
7296	this.data = data;
7297	this.nodeType = NodeType.COMMENT;
7298}
7299
7300Comment.prototype = Object.create(Node.prototype);
7301Comment.prototype.visit = function(treeParser) {
7302	treeParser.comment(this.data, 0, this.data.length, this);
7303};
7304function CDATA(locator) {
7305	ParentNode.call(this, locator);
7306	this.nodeType = NodeType.CDATA;
7307}
7308
7309CDATA.prototype = Object.create(ParentNode.prototype);
7310CDATA.prototype.visit = function(treeParser) {
7311	treeParser.startCDATA(this);
7312};
7313CDATA.prototype.revisit = function(treeParser) {
7314	treeParser.endCDATA(this.endLocator);
7315};
7316function Entity(name) {
7317	ParentNode.call(this);
7318	this.name = name;
7319	this.nodeType = NodeType.ENTITY;
7320}
7321
7322Entity.prototype = Object.create(ParentNode.prototype);
7323Entity.prototype.visit = function(treeParser) {
7324	treeParser.startEntity(this.name, this);
7325};
7326Entity.prototype.revisit = function(treeParser) {
7327	treeParser.endEntity(this.name);
7328};
7329
7330function SkippedEntity(name) {
7331	Node.call(this);
7332	this.name = name;
7333	this.nodeType = NodeType.SKIPPED_ENTITY;
7334}
7335
7336SkippedEntity.prototype = Object.create(Node.prototype);
7337SkippedEntity.prototype.visit = function(treeParser) {
7338	treeParser.skippedEntity(this.name, this);
7339};
7340function ProcessingInstruction(target, data) {
7341	Node.call(this);
7342	this.target = target;
7343	this.data = data;
7344}
7345
7346ProcessingInstruction.prototype = Object.create(Node.prototype);
7347ProcessingInstruction.prototype.visit = function(treeParser) {
7348	treeParser.processingInstruction(this.target, this.data, this);
7349};
7350ProcessingInstruction.prototype.getNodeType = function() {
7351	return NodeType.PROCESSING_INSTRUCTION;
7352};
7353function DTD(name, publicIdentifier, systemIdentifier) {
7354	ParentNode.call(this);
7355	this.name = name;
7356	this.publicIdentifier = publicIdentifier;
7357	this.systemIdentifier = systemIdentifier;
7358	this.nodeType = NodeType.DTD;
7359}
7360
7361DTD.prototype = Object.create(ParentNode.prototype);
7362DTD.prototype.visit = function(treeParser) {
7363	treeParser.startDTD(this.name, this.publicIdentifier, this.systemIdentifier, this);
7364};
7365DTD.prototype.revisit = function(treeParser) {
7366	treeParser.endDTD();
7367};
7368
7369exports.SAXTreeBuilder = SAXTreeBuilder;
7370
7371},
7372{"../TreeBuilder":6,"util":20}],
737311:[function(_dereq_,module,exports){
7374function TreeParser(contentHandler, lexicalHandler){
7375	this.contentHandler;
7376	this.lexicalHandler;
7377	this.locatorDelegate;
7378
7379	if (!contentHandler) {

7380		throw new IllegalArgumentException("contentHandler was null.");
7381	}
7382	this.contentHandler = contentHandler;
7383	if (!lexicalHandler) {
7384		this.lexicalHandler = new NullLexicalHandler();
7385	} else {
7386		this.lexicalHandler = lexicalHandler;
7387	}
7388}
7389TreeParser.prototype.parse = function(node) {
7390	this.contentHandler.documentLocator = this;
7391	var current = node;
7392	var next;
7393	for (;;) {
7394		current.visit(this);
7395		if (next = current.firstChild) {
7396			current = next;
7397			continue;
7398		}
7399		for (;;) {
7400			current.revisit(this);
7401			if (current == node) {
7402				return;
7403			}
7404			if (next = current.nextSibling) {
7405				current = next;
7406				break;
7407			}
7408			current = current.parentNode;
7409		}
7410	}
7411};
7412TreeParser.prototype.characters = function(ch, start, length, locator) {
7413	this.locatorDelegate = locator;
7414	this.contentHandler.characters(ch, start, length);
7415};
7416TreeParser.prototype.endDocument = function(locator) {
7417	this.locatorDelegate = locator;
7418	this.contentHandler.endDocument();
7419};
7420TreeParser.prototype.endElement = function(uri, localName, qName, locator) {
7421	this.locatorDelegate = locator;
7422	this.contentHandler.endElement(uri, localName, qName);
7423};
7424TreeParser.prototype.endPrefixMapping = function(prefix, locator) {
7425	this.locatorDelegate = locator;
7426	this.contentHandler.endPrefixMapping(prefix);
7427};
7428TreeParser.prototype.ignorableWhitespace = function(ch, start, length, locator) {
7429	this.locatorDelegate = locator;
7430	this.contentHandler.ignorableWhitespace(ch, start, length);
7431};
7432TreeParser.prototype.processingInstruction = function(target, data, locator) {
7433	this.locatorDelegate = locator;
7434	this.contentHandler.processingInstruction(target, data);
7435};
7436TreeParser.prototype.skippedEntity = function(name, locator) {
7437	this.locatorDelegate = locator;
7438	this.contentHandler.skippedEntity(name);
7439};
7440TreeParser.prototype.startDocument = function(locator) {
7441	this.locatorDelegate = locator;
7442	this.contentHandler.startDocument();
7443};
7444TreeParser.prototype.startElement = function(uri, localName, qName, atts, locator) {
7445	this.locatorDelegate = locator;
7446	this.contentHandler.startElement(uri, localName, qName, atts);
7447};
7448TreeParser.prototype.startPrefixMapping = function(prefix, uri, locator) {
7449	this.locatorDelegate = locator;
7450	this.contentHandler.startPrefixMapping(prefix, uri);
7451};
7452TreeParser.prototype.comment = function(ch, start, length, locator) {
7453	this.locatorDelegate = locator;
7454	this.lexicalHandler.comment(ch, start, length);
7455};
7456TreeParser.prototype.endCDATA = function(locator) {
7457	this.locatorDelegate = locator;
7458	this.lexicalHandler.endCDATA();
7459};
7460TreeParser.prototype.endDTD = function(locator) {
7461	this.locatorDelegate = locator;
7462	this.lexicalHandler.endDTD();
7463};
7464TreeParser.prototype.endEntity = function(name, locator) {
7465	this.locatorDelegate = locator;
7466	this.lexicalHandler.endEntity(name);
7467};
7468TreeParser.prototype.startCDATA = function(locator) {
7469	this.locatorDelegate = locator;
7470	this.lexicalHandler.startCDATA();
7471};
7472TreeParser.prototype.startDTD = function(name, publicId, systemId, locator) {
7473	this.locatorDelegate = locator;
7474	this.lexicalHandler.startDTD(name, publicId, systemId);
7475};
7476TreeParser.prototype.startEntity = function(name, locator) {
7477	this.locatorDelegate = locator;
7478	this.lexicalHandler.startEntity(name);
7479};
7480
7481Object.defineProperty(TreeParser.prototype, 'columnNumber', {
7482	get: function() {
7483		if (!this.locatorDelegate)
7484			return -1;
7485		else
7486			return this.locatorDelegate.columnNumber;
7487	}
7488});
7489
7490Object.defineProperty(TreeParser.prototype, 'lineNumber', {
7491	get: function() {
7492		if (!this.locatorDelegate)
7493			return -1;
7494		else
7495			return this.locatorDelegate.lineNumber;
7496	}
7497});
7498function NullLexicalHandler() {
7499
7500}
7501
7502NullLexicalHandler.prototype.comment = function() {};
7503NullLexicalHandler.prototype.endCDATA = function() {};
7504NullLexicalHandler.prototype.endDTD = function() {};
7505NullLexicalHandler.prototype.endEntity = function() {};
7506NullLexicalHandler.prototype.startCDATA = function() {};
7507NullLexicalHandler.prototype.startDTD = function() {};
7508NullLexicalHandler.prototype.startEntity = function() {};
7509
7510exports.TreeParser = TreeParser;
7511
7512},
7513{}],
751412:[function(_dereq_,module,exports){
7515module.exports = {
7516	"Aacute;": "\u00C1",
7517	"Aacute": "\u00C1",
7518	"aacute;": "\u00E1",
7519	"aacute": "\u00E1",
7520	"Abreve;": "\u0102",
7521	"abreve;": "\u0103",
7522	"ac;": "\u223E",
7523	"acd;": "\u223F",
7524	"acE;": "\u223E\u0333",
7525	"Acirc;": "\u00C2",
7526	"Acirc": "\u00C2",
7527	"acirc;": "\u00E2",
7528	"acirc": "\u00E2",
7529	"acute;": "\u00B4",
7530	"acute": "\u00B4",
7531	"Acy;": "\u0410",
7532	"acy;": "\u0430",
7533	"AElig;": "\u00C6",
7534	"AElig": "\u00C6",
7535	"aelig;": "\u00E6",
7536	"aelig": "\u00E6",
7537	"af;": "\u2061",
7538	"Afr;": "\uD835\uDD04",
7539	"afr;": "\uD835\uDD1E",
7540	"Agrave;": "\u00C0",
7541	"Agrave": "\u00C0",
7542	"agrave;": "\u00E0",
7543	"agrave": "\u00E0",
7544	"alefsym;": "\u2135",
7545	"aleph;": "\u2135",
7546	"Alpha;": "\u0391",
7547	"alpha;": "\u03B1",
7548	"Amacr;": "\u0100",
7549	"amacr;": "\u0101",
7550	"amalg;": "\u2A3F",
7551	"amp;": "\u0026",
7552	"amp": "\u0026",
7553	"AMP;": "\u0026",
7554	"AMP": "\u0026",
7555	"andand;": "\u2A55",
7556	"And;": "\u2A53",
7557	"and;": "\u2227",
7558	"andd;": "\u2A5C",

7559	"andslope;": "\u2A58",
7560	"andv;": "\u2A5A",
7561	"ang;": "\u2220",
7562	"ange;": "\u29A4",
7563	"angle;": "\u2220",
7564	"angmsdaa;": "\u29A8",
7565	"angmsdab;": "\u29A9",
7566	"angmsdac;": "\u29AA",
7567	"angmsdad;": "\u29AB",
7568	"angmsdae;": "\u29AC",
7569	"angmsdaf;": "\u29AD",
7570	"angmsdag;": "\u29AE",
7571	"angmsdah;": "\u29AF",
7572	"angmsd;": "\u2221",
7573	"angrt;": "\u221F",
7574	"angrtvb;": "\u22BE",
7575	"angrtvbd;": "\u299D",
7576	"angsph;": "\u2222",
7577	"angst;": "\u00C5",
7578	"angzarr;": "\u237C",
7579	"Aogon;": "\u0104",
7580	"aogon;": "\u0105",
7581	"Aopf;": "\uD835\uDD38",
7582	"aopf;": "\uD835\uDD52",
7583	"apacir;": "\u2A6F",
7584	"ap;": "\u2248",
7585	"apE;": "\u2A70",
7586	"ape;": "\u224A",
7587	"apid;": "\u224B",
7588	"apos;": "\u0027",
7589	"ApplyFunction;": "\u2061",
7590	"approx;": "\u2248",
7591	"approxeq;": "\u224A",
7592	"Aring;": "\u00C5",
7593	"Aring": "\u00C5",
7594	"aring;": "\u00E5",
7595	"aring": "\u00E5",
7596	"Ascr;": "\uD835\uDC9C",
7597	"ascr;": "\uD835\uDCB6",
7598	"Assign;": "\u2254",
7599	"ast;": "\u002A",
7600	"asymp;": "\u2248",
7601	"asympeq;": "\u224D",
7602	"Atilde;": "\u00C3",
7603	"Atilde": "\u00C3",
7604	"atilde;": "\u00E3",
7605	"atilde": "\u00E3",
7606	"Auml;": "\u00C4",
7607	"Auml": "\u00C4",
7608	"auml;": "\u00E4",
7609	"auml": "\u00E4",
7610	"awconint;": "\u2233",
7611	"awint;": "\u2A11",
7612	"backcong;": "\u224C",
7613	"backepsilon;": "\u03F6",
7614	"backprime;": "\u2035",
7615	"backsim;": "\u223D",
7616	"backsimeq;": "\u22CD",
7617	"Backslash;": "\u2216",
7618	"Barv;": "\u2AE7",
7619	"barvee;": "\u22BD",
7620	"barwed;": "\u2305",
7621	"Barwed;": "\u2306",
7622	"barwedge;": "\u2305",
7623	"bbrk;": "\u23B5",
7624	"bbrktbrk;": "\u23B6",
7625	"bcong;": "\u224C",
7626	"Bcy;": "\u0411",
7627	"bcy;": "\u0431",
7628	"bdquo;": "\u201E",
7629	"becaus;": "\u2235",
7630	"because;": "\u2235",
7631	"Because;": "\u2235",
7632	"bemptyv;": "\u29B0",
7633	"bepsi;": "\u03F6",
7634	"bernou;": "\u212C",
7635	"Bernoullis;": "\u212C",
7636	"Beta;": "\u0392",
7637	"beta;": "\u03B2",
7638	"beth;": "\u2136",
7639	"between;": "\u226C",
7640	"Bfr;": "\uD835\uDD05",
7641	"bfr;": "\uD835\uDD1F",
7642	"bigcap;": "\u22C2",
7643	"bigcirc;": "\u25EF",
7644	"bigcup;": "\u22C3",
7645	"bigodot;": "\u2A00",
7646	"bigoplus;": "\u2A01",
7647	"bigotimes;": "\u2A02",
7648	"bigsqcup;": "\u2A06",
7649	"bigstar;": "\u2605",
7650	"bigtriangledown;": "\u25BD",
7651	"bigtriangleup;": "\u25B3",
7652	"biguplus;": "\u2A04",
7653	"bigvee;": "\u22C1",
7654	"bigwedge;": "\u22C0",
7655	"bkarow;": "\u290D",
7656	"blacklozenge;": "\u29EB",
7657	"blacksquare;": "\u25AA",
7658	"blacktriangle;": "\u25B4",
7659	"blacktriangledown;": "\u25BE",
7660	"blacktriangleleft;": "\u25C2",
7661	"blacktriangleright;": "\u25B8",
7662	"blank;": "\u2423",
7663	"blk12;": "\u2592",
7664	"blk14;": "\u2591",
7665	"blk34;": "\u2593",
7666	"block;": "\u2588",
7667	"bne;": "\u003D\u20E5",
7668	"bnequiv;": "\u2261\u20E5",
7669	"bNot;": "\u2AED",
7670	"bnot;": "\u2310",
7671	"Bopf;": "\uD835\uDD39",
7672	"bopf;": "\uD835\uDD53",
7673	"bot;": "\u22A5",
7674	"bottom;": "\u22A5",
7675	"bowtie;": "\u22C8",
7676	"boxbox;": "\u29C9",
7677	"boxdl;": "\u2510",
7678	"boxdL;": "\u2555",
7679	"boxDl;": "\u2556",
7680	"boxDL;": "\u2557",
7681	"boxdr;": "\u250C",
7682	"boxdR;": "\u2552",
7683	"boxDr;": "\u2553",
7684	"boxDR;": "\u2554",
7685	"boxh;": "\u2500",
7686	"boxH;": "\u2550",
7687	"boxhd;": "\u252C",
7688	"boxHd;": "\u2564",
7689	"boxhD;": "\u2565",
7690	"boxHD;": "\u2566",
7691	"boxhu;": "\u2534",
7692	"boxHu;": "\u2567",
7693	"boxhU;": "\u2568",
7694	"boxHU;": "\u2569",
7695	"boxminus;": "\u229F",
7696	"boxplus;": "\u229E",
7697	"boxtimes;": "\u22A0",
7698	"boxul;": "\u2518",
7699	"boxuL;": "\u255B",
7700	"boxUl;": "\u255C",
7701	"boxUL;": "\u255D",
7702	"boxur;": "\u2514",
7703	"boxuR;": "\u2558",
7704	"boxUr;": "\u2559",
7705	"boxUR;": "\u255A",
7706	"boxv;": "\u2502",
7707	"boxV;": "\u2551",
7708	"boxvh;": "\u253C",
7709	"boxvH;": "\u256A",
7710	"boxVh;": "\u256B",
7711	"boxVH;": "\u256C",
7712	"boxvl;": "\u2524",
7713	"boxvL;": "\u2561",
7714	"boxVl;": "\u2562",
7715	"boxVL;": "\u2563",
7716	"boxvr;": "\u251C",
7717	"boxvR;": "\u255E",
7718	"boxVr;": "\u255F",
7719	"boxVR;": "\u2560",
7720	"bprime;": "\u2035",
7721	"breve;": "\u02D8",
7722	"Breve;": "\u02D8",
7723	"brvbar;": "\u00A6",
7724	"brvbar": "\u00A6",
7725	"bscr;": "\uD835\uDCB7",
7726	"Bscr;": "\u212C",
7727	"bsemi;": "\u204F",
7728	"bsim;": "\u223D",
7729	"bsime;": "\u22CD",
7730	"bsolb;": "\u29C5",
7731	"bsol;": "\u005C",
7732	"bsolhsub;": "\u27C8",
7733	"bull;": "\u2022",
7734	"bullet;": "\u2022",
7735	"bump;": "\u224E",
7736	"bumpE;": "\u2AAE",
7737	"bumpe;": "\u224F",
7738	"Bumpeq;": "\u224E",
7739	"bumpeq;": "\u224F",
7740	"Cacute;": "\u0106",
7741	"cacute;": "\u0107",
7742	"capand;": "\u2A44",
7743	"capbrcup;": "\u2A49",
7744	"capcap;": "\u2A4B",
7745	"cap;": "\u2229",
7746	"Cap;": "\u22D2",
7747	"capcup;": "\u2A47",
7748	"capdot;": "\u2A40",
7749	"CapitalDifferentialD;

7749": "\u2145",
7750	"caps;": "\u2229\uFE00",
7751	"caret;": "\u2041",
7752	"caron;": "\u02C7",
7753	"Cayleys;": "\u212D",
7754	"ccaps;": "\u2A4D",
7755	"Ccaron;": "\u010C",
7756	"ccaron;": "\u010D",
7757	"Ccedil;": "\u00C7",
7758	"Ccedil": "\u00C7",
7759	"ccedil;": "\u00E7",
7760	"ccedil": "\u00E7",
7761	"Ccirc;": "\u0108",
7762	"ccirc;": "\u0109",
7763	"Cconint;": "\u2230",
7764	"ccups;": "\u2A4C",
7765	"ccupssm;": "\u2A50",
7766	"Cdot;": "\u010A",
7767	"cdot;": "\u010B",
7768	"cedil;": "\u00B8",
7769	"cedil": "\u00B8",
7770	"Cedilla;": "\u00B8",
7771	"cemptyv;": "\u29B2",
7772	"cent;": "\u00A2",
7773	"cent": "\u00A2",
7774	"centerdot;": "\u00B7",
7775	"CenterDot;": "\u00B7",
7776	"cfr;": "\uD835\uDD20",
7777	"Cfr;": "\u212D",
7778	"CHcy;": "\u0427",
7779	"chcy;": "\u0447",
7780	"check;": "\u2713",
7781	"checkmark;": "\u2713",
7782	"Chi;": "\u03A7",
7783	"chi;": "\u03C7",
7784	"circ;": "\u02C6",
7785	"circeq;": "\u2257",
7786	"circlearrowleft;": "\u21BA",
7787	"circlearrowright;": "\u21BB",
7788	"circledast;": "\u229B",
7789	"circledcirc;": "\u229A",
7790	"circleddash;": "\u229D",
7791	"CircleDot;": "\u2299",
7792	"circledR;": "\u00AE",
7793	"circledS;": "\u24C8",
7794	"CircleMinus;": "\u2296",
7795	"CirclePlus;": "\u2295",
7796	"CircleTimes;": "\u2297",
7797	"cir;": "\u25CB",
7798	"cirE;": "\u29C3",
7799	"cire;": "\u2257",
7800	"cirfnint;": "\u2A10",
7801	"cirmid;": "\u2AEF",
7802	"cirscir;": "\u29C2",
7803	"ClockwiseContourIntegral;": "\u2232",
7804	"CloseCurlyDoubleQuote;": "\u201D",
7805	"CloseCurlyQuote;": "\u2019",
7806	"clubs;": "\u2663",
7807	"clubsuit;": "\u2663",
7808	"colon;": "\u003A",
7809	"Colon;": "\u2237",
7810	"Colone;": "\u2A74",
7811	"colone;": "\u2254",
7812	"coloneq;": "\u2254",
7813	"comma;": "\u002C",
7814	"commat;": "\u0040",
7815	"comp;": "\u2201",
7816	"compfn;": "\u2218",
7817	"complement;": "\u2201",
7818	"complexes;": "\u2102",
7819	"cong;": "\u2245",
7820	"congdot;": "\u2A6D",
7821	"Congruent;": "\u2261",
7822	"conint;": "\u222E",
7823	"Conint;": "\u222F",
7824	"ContourIntegral;": "\u222E",
7825	"copf;": "\uD835\uDD54",
7826	"Copf;": "\u2102",
7827	"coprod;": "\u2210",
7828	"Coproduct;": "\u2210",
7829	"copy;": "\u00A9",
7830	"copy": "\u00A9",
7831	"COPY;": "\u00A9",
7832	"COPY": "\u00A9",
7833	"copysr;": "\u2117",
7834	"CounterClockwiseContourIntegral;": "\u2233",
7835	"crarr;": "\u21B5",
7836	"cross;": "\u2717",
7837	"Cross;": "\u2A2F",
7838	"Cscr;": "\uD835\uDC9E",
7839	"cscr;": "\uD835\uDCB8",
7840	"csub;": "\u2ACF",
7841	"csube;": "\u2AD1",
7842	"csup;": "\u2AD0",
7843	"csupe;": "\u2AD2",
7844	"ctdot;": "\u22EF",
7845	"cudarrl;": "\u2938",
7846	"cudarrr;": "\u2935",
7847	"cuepr;": "\u22DE",
7848	"cuesc;": "\u22DF",
7849	"cularr;": "\u21B6",
7850	"cularrp;": "\u293D",
7851	"cupbrcap;": "\u2A48",
7852	"cupcap;": "\u2A46",
7853	"CupCap;": "\u224D",
7854	"cup;": "\u222A",
7855	"Cup;": "\u22D3",
7856	"cupcup;": "\u2A4A",
7857	"cupdot;": "\u228D",
7858	"cupor;": "\u2A45",
7859	"cups;": "\u222A\uFE00",
7860	"curarr;": "\u21B7",
7861	"curarrm;": "\u293C",
7862	"curlyeqprec;": "\u22DE",
7863	"curlyeqsucc;": "\u22DF",
7864	"curlyvee;": "\u22CE",
7865	"curlywedge;": "\u22CF",
7866	"curren;": "\u00A4",
7867	"curren": "\u00A4",
7868	"curvearrowleft;": "\u21B6",
7869	"curvearrowright;": "\u21B7",
7870	"cuvee;": "\u22CE",
7871	"cuwed;": "\u22CF",
7872	"cwconint;": "\u2232",
7873	"cwint;": "\u2231",
7874	"cylcty;": "\u232D",
7875	"dagger;": "\u2020",
7876	"Dagger;": "\u2021",
7877	"daleth;": "\u2138",
7878	"darr;": "\u2193",
7879	"Darr;": "\u21A1",
7880	"dArr;": "\u21D3",
7881	"dash;": "\u2010",
7882	"Dashv;": "\u2AE4",
7883	"dashv;": "\u22A3",
7884	"dbkarow;": "\u290F",
7885	"dblac;": "\u02DD",
7886	"Dcaron;": "\u010E",
7887	"dcaron;": "\u010F",
7888	"Dcy;": "\u0414",
7889	"dcy;": "\u0434",
7890	"ddagger;": "\u2021",
7891	"ddarr;": "\u21CA",
7892	"DD;": "\u2145",
7893	"dd;": "\u2146",
7894	"DDotrahd;": "\u2911",
7895	"ddotseq;": "\u2A77",
7896	"deg;": "\u00B0",
7897	"deg": "\u00B0",
7898	"Del;": "\u2207",
7899	"Delta;": "\u0394",
7900	"delta;": "\u03B4",
7901	"demptyv;": "\u29B1",
7902	"dfisht;": "\u297F",
7903	"Dfr;": "\uD835\uDD07",
7904	"dfr;": "\uD835\uDD21",
7905	"dHar;": "\u2965",
7906	"dharl;": "\u21C3",
7907	"dharr;": "\u21C2",
7908	"DiacriticalAcute;": "\u00B4",
7909	"DiacriticalDot;": "\u02D9",
7910	"DiacriticalDoubleAcute;": "\u02DD",
7911	"DiacriticalGrave;": "\u0060",
7912	"DiacriticalTilde;": "\u02DC",
7913	"diam;": "\u22C4",
7914	"diamond;": "\u22C4",
7915	"Diamond;": "\u22C4",
7916	"diamondsuit;": "\u2666",
7917	"diams;": "\u2666",
7918	"die;": "\u00A8",
7919	"DifferentialD;": "\u2146",
7920	"digamma;": "\u03DD",
7921	"disin;": "\u22F2",
7922	"div;": "\u00F7",
7923	"divide;": "\u00F7",
7924	"divide": "\u00F7",
7925	"divideontimes;": "\u22C7",
7926	"divonx;": "\u22C7",
7927	"DJcy;": "\u0402",
7928	"djcy;": "\u0452",
7929	"dlcorn;": "\u231E",
7930	"dlcrop;": "\u230D",
7931	"dollar;": "\u0024",
7932	"Dopf;": "\uD835\uDD3B",
7933	"dopf;": "\uD835\uDD55",
7934	"Dot;": "\u00A8",
7935	"dot;": "\u02D9",
7936	"DotDot;": "\u20DC",
7937	"doteq;": "\u2250",
7938	"doteqdot;": "\u2251",
7939	"DotEqual;": "\u2250",
7940	"dotminus;": "\u2238",
7941	"dotplus;": "\u2214",
7942	"dotsquare;": "\u22A1",
7943	"doublebarwedge;": "\u2306",
7944	"DoubleContourIntegral;": "\u222F",
7945	"DoubleDot;": "\u00A8",
7946	"DoubleDownArrow;": "\u21D3",
7947	"DoubleLeftArrow;

7947": "\u21D0",
7948	"DoubleLeftRightArrow;": "\u21D4",
7949	"DoubleLeftTee;": "\u2AE4",
7950	"DoubleLongLeftArrow;": "\u27F8",
7951	"DoubleLongLeftRightArrow;": "\u27FA",
7952	"DoubleLongRightArrow;": "\u27F9",
7953	"DoubleRightArrow;": "\u21D2",
7954	"DoubleRightTee;": "\u22A8",
7955	"DoubleUpArrow;": "\u21D1",
7956	"DoubleUpDownArrow;": "\u21D5",
7957	"DoubleVerticalBar;": "\u2225",
7958	"DownArrowBar;": "\u2913",
7959	"downarrow;": "\u2193",
7960	"DownArrow;": "\u2193",
7961	"Downarrow;": "\u21D3",
7962	"DownArrowUpArrow;": "\u21F5",
7963	"DownBreve;": "\u0311",
7964	"downdownarrows;": "\u21CA",
7965	"downharpoonleft;": "\u21C3",
7966	"downharpoonright;": "\u21C2",
7967	"DownLeftRightVector;": "\u2950",
7968	"DownLeftTeeVector;": "\u295E",
7969	"DownLeftVectorBar;": "\u2956",
7970	"DownLeftVector;": "\u21BD",
7971	"DownRightTeeVector;": "\u295F",
7972	"DownRightVectorBar;": "\u2957",
7973	"DownRightVector;": "\u21C1",
7974	"DownTeeArrow;": "\u21A7",
7975	"DownTee;": "\u22A4",
7976	"drbkarow;": "\u2910",
7977	"drcorn;": "\u231F",
7978	"drcrop;": "\u230C",
7979	"Dscr;": "\uD835\uDC9F",
7980	"dscr;": "\uD835\uDCB9",
7981	"DScy;": "\u0405",
7982	"dscy;": "\u0455",
7983	"dsol;": "\u29F6",
7984	"Dstrok;": "\u0110",
7985	"dstrok;": "\u0111",
7986	"dtdot;": "\u22F1",
7987	"dtri;": "\u25BF",
7988	"dtrif;": "\u25BE",
7989	"duarr;": "\u21F5",
7990	"duhar;": "\u296F",
7991	"dwangle;": "\u29A6",
7992	"DZcy;": "\u040F",
7993	"dzcy;": "\u045F",
7994	"dzigrarr;": "\u27FF",
7995	"Eacute;": "\u00C9",
7996	"Eacute": "\u00C9",
7997	"eacute;": "\u00E9",
7998	"eacute": "\u00E9",
7999	"easter;": "\u2A6E",
8000	"Ecaron;": "\u011A",
8001	"ecaron;": "\u011B",
8002	"Ecirc;": "\u00CA",
8003	"Ecirc": "\u00CA",
8004	"ecirc;": "\u00EA",
8005	"ecirc": "\u00EA",
8006	"ecir;": "\u2256",
8007	"ecolon;": "\u2255",
8008	"Ecy;": "\u042D",
8009	"ecy;": "\u044D",
8010	"eDDot;": "\u2A77",
8011	"Edot;": "\u0116",
8012	"edot;": "\u0117",
8013	"eDot;": "\u2251",
8014	"ee;": "\u2147",
8015	"efDot;": "\u2252",
8016	"Efr;": "\uD835\uDD08",
8017	"efr;": "\uD835\uDD22",
8018	"eg;": "\u2A9A",
8019	"Egrave;": "\u00C8",
8020	"Egrave": "\u00C8",
8021	"egrave;": "\u00E8",
8022	"egrave": "\u00E8",
8023	"egs;": "\u2A96",
8024	"egsdot;": "\u2A98",
8025	"el;": "\u2A99",
8026	"Element;": "\u2208",
8027	"elinters;": "\u23E7",
8028	"ell;": "\u2113",
8029	"els;": "\u2A95",
8030	"elsdot;": "\u2A97",
8031	"Emacr;": "\u0112",
8032	"emacr;": "\u0113",
8033	"empty;": "\u2205",
8034	"emptyset;": "\u2205",
8035	"EmptySmallSquare;": "\u25FB",
8036	"emptyv;": "\u2205",
8037	"EmptyVerySmallSquare;": "\u25AB",
8038	"emsp13;": "\u2004",
8039	"emsp14;": "\u2005",
8040	"emsp;": "\u2003",
8041	"ENG;": "\u014A",
8042	"eng;": "\u014B",
8043	"ensp;": "\u2002",
8044	"Eogon;": "\u0118",
8045	"eogon;": "\u0119",
8046	"Eopf;": "\uD835\uDD3C",
8047	"eopf;": "\uD835\uDD56",
8048	"epar;": "\u22D5",
8049	"eparsl;": "\u29E3",
8050	"eplus;": "\u2A71",
8051	"epsi;": "\u03B5",
8052	"Epsilon;": "\u0395",
8053	"epsilon;": "\u03B5",
8054	"epsiv;": "\u03F5",
8055	"eqcirc;": "\u2256",
8056	"eqcolon;": "\u2255",
8057	"eqsim;": "\u2242",
8058	"eqslantgtr;": "\u2A96",
8059	"eqslantless;": "\u2A95",
8060	"Equal;": "\u2A75",
8061	"equals;": "\u003D",
8062	"EqualTilde;": "\u2242",
8063	"equest;": "\u225F",
8064	"Equilibrium;": "\u21CC",
8065	"equiv;": "\u2261",
8066	"equivDD;": "\u2A78",
8067	"eqvparsl;": "\u29E5",
8068	"erarr;": "\u2971",
8069	"erDot;": "\u2253",
8070	"escr;": "\u212F",
8071	"Escr;": "\u2130",
8072	"esdot;": "\u2250",
8073	"Esim;": "\u2A73",
8074	"esim;": "\u2242",
8075	"Eta;": "\u0397",
8076	"eta;": "\u03B7",
8077	"ETH;": "\u00D0",
8078	"ETH": "\u00D0",
8079	"eth;": "\u00F0",
8080	"eth": "\u00F0",
8081	"Euml;": "\u00CB",
8082	"Euml": "\u00CB",
8083	"euml;": "\u00EB",
8084	"euml": "\u00EB",
8085	"euro;": "\u20AC",
8086	"excl;": "\u0021",
8087	"exist;": "\u2203",
8088	"Exists;": "\u2203",
8089	"expectation;": "\u2130",
8090	"exponentiale;": "\u2147",
8091	"ExponentialE;": "\u2147",
8092	"fallingdotseq;": "\u2252",
8093	"Fcy;": "\u0424",
8094	"fcy;": "\u0444",
8095	"female;": "\u2640",
8096	"ffilig;": "\uFB03",
8097	"fflig;": "\uFB00",
8098	"ffllig;": "\uFB04",
8099	"Ffr;": "\uD835\uDD09",
8100	"ffr;": "\uD835\uDD23",
8101	"filig;": "\uFB01",
8102	"FilledSmallSquare;": "\u25FC",
8103	"FilledVerySmallSquare;": "\u25AA",
8104	"fjlig;": "\u0066\u006A",
8105	"flat;": "\u266D",
8106	"fllig;": "\uFB02",
8107	"fltns;": "\u25B1",
8108	"fnof;": "\u0192",
8109	"Fopf;": "\uD835\uDD3D",
8110	"fopf;": "\uD835\uDD57",
8111	"forall;": "\u2200",
8112	"ForAll;": "\u2200",
8113	"fork;": "\u22D4",
8114	"forkv;": "\u2AD9",
8115	"Fouriertrf;": "\u2131",
8116	"fpartint;": "\u2A0D",
8117	"frac12;": "\u00BD",
8118	"frac12": "\u00BD",
8119	"frac13;": "\u2153",
8120	"frac14;": "\u00BC",
8121	"frac14": "\u00BC",
8122	"frac15;": "\u2155",
8123	"frac16;": "\u2159",
8124	"frac18;": "\u215B",
8125	"frac23;": "\u2154",
8126	"frac25;": "\u2156",
8127	"frac34;": "\u00BE",
8128	"frac34": "\u00BE",
8129	"frac35;": "\u2157",
8130	"frac38;": "\u215C",
8131	"frac45;": "\u2158",
8132	"frac56;": "\u215A",
8133	"frac58;": "\u215D",
8134	"frac78;": "\u215E",
8135	"frasl;": "\u2044",
8136	"frown;": "\u2322",
8137	"fscr;": "\uD835\uDCBB",
8138	"Fscr;": "\u2131",
8139	"gacute;": "\u01F5",
8140	"Gamma;": "\u0393",
8141	"gamma;": "\u03B3",
8142	"Gammad;": "\u03DC",
8143	"gammad;": "\u03DD",
8144	"gap;": "\u2A86",
8145	"Gbreve;": "\u011E",
8146	"gbreve;": "\u011F",
8147	"Gcedil;": "\u0122",
8148	"Gcirc;": "\u011C",
8149	"gcirc;": "\u011D",
8150	"Gcy;": "\u0413",
8151	"gcy;": "\u0433",
8152	"Gdot;": "\u0120",
8153	"gdot;": "\u0121",
8154	"ge;": "\u2265",
8155	"gE;": "\u2267",
8156	"gEl;": "\u2A8C",
8157	"gel;": "\u22DB",
8158	"geq;": "\u2265",
8159	"geqq;": "\u2267",
8160	"geqslant;": "\u2A7E",
8161	"gescc;": "\u2AA9",
8162	"ges;": "\u2A7E",
8163	"gesdot;": "\u2A80",
8164	"gesdoto;": "\u2A82",
8165	"gesdotol;": "\u2A84",
8166	"gesl;": "\u22DB\uFE00",
8167	"gesles;": "\u2A94",
8168	"Gfr;": "\uD835\uDD0A",
8169	"gfr;": "\uD835\uDD24",
8170	"gg;": "\u226B",
8171	"Gg;": "\u22D9",
8172	"ggg;": "\u22D9",
8173	"gimel;": "\u2137",
8174	"GJcy;": "\u0403",
8175	"gjcy;": "\u0453",
8176	"gla;": "\u2AA5",
8177	"gl;": "\u2277",
8178	"glE;": "\u2A92",
8179	"glj;": "\u2AA4",
8180	"gnap;": "\u2A8A",
8181	"gnapprox;": "\u2A8A",
8182	"gne;": "\u2A88",
8183	"gnE;": "\u2269",
8184	"gneq;": "\u2A88",
8185	"gneqq;": "\u2269",
8186	"gnsim;": "\u22E7",
8187	"Gopf;": "\uD835\uDD3E",
8188	"gopf;": "\uD835\uDD58",
8189	"grave;": "\u0060",
8190	"GreaterEqual;": "\u2265",
8191	"GreaterEqualLess;": "\u22DB",
8192	"GreaterFullEqual;": "\u2267",
8193	"GreaterGreater;": "\u2AA2",
8194	"GreaterLess;": "\u2277",
8195	"GreaterSlantEqual;": "\u2A7E",
8196	"GreaterTilde;": "\u2273",
8197	"Gscr;": "\uD835\uDCA2",
8198	"gscr;": "\u210A",
8199	"gsim;": "\u2273",
8200	"gsime;": "\u2A8E",
8201	"gsiml;": "\u2A90",
8202	"gtcc;": "\u2AA7",
8203	"gtcir;": "\u2A7A",
8204	"gt;": "\u003E",
8205	"gt": "\u003E",
8206	"GT;": "\u003E",
8207	"GT": "\u003E",
8208	"Gt;": "\u226B",
8209	"gtdot;": "\u22D7",
8210	"gtlPar;": "\u2995",
8211	"gtquest;": "\u2A7C",
8212	"gtrapprox;": "\u2A86",
8213	"gtrarr;": "\u2978",
8214	"gtrdot;": "\u22D7",
8215	"gtreqless;": "\u22DB",
8216	"gtreqqless;": "\u2A8C",
8217	"gtrless;": "\u2277",
8218	"gtrsim;": "\u2273",
8219	"gvertneqq;": "\u2269\uFE00",
8220	"gvnE;": "\u2269\uFE00",
8221	"Hacek;": "\u02C7",
8222	"hairsp;": "\u200A",
8223	"half;": "\u00BD",
8224	"hamilt;": "\u210B",
8225	"HARDcy;": "\u042A",
8226	"hardcy;": "\u044A",
8227	"harrcir;": "\u2948",
8228	"harr;": "\u2194",
8229	"hArr;": "\u21D4",
8230	"harrw;": "\u21AD",
8231	"Hat;": "\u005E",
8232	"hbar;": "\u210F",
8233	"Hcirc;": "\u0124",
8234	"hcirc;": "\u0125",
8235	"hearts;": "\u2665",
8236	"heartsuit;": "\u2665",
8237	"hellip;": "\u2026",
8238	"hercon;": "\u22B9",
8239	"hfr;": "\uD835\uDD25",
8240	"Hfr;": "\u210C",
8241	"HilbertSpace;": "\u210B",
8242	"hksearow;": "\u2925",
8243	"hkswarow;": "\u2926",
8244	"hoarr;": "\u21FF",
8245	"homtht;": "\u223B",
8246	"hookleftarrow;": "\u21A9",
8247	"hookrightarrow;": "\u21AA",
8248	"hopf;": "\uD835\uDD59",
8249	"Hopf;": "\u210D",
8250	"horbar;": "\u2015",
8251	"HorizontalLine;": "\u2500",
8252	"hscr;": "\uD835\uDCBD",
8253	"Hscr;": "\u210B",
8254	"hslash;": "\u210F",
8255	"Hstrok;": "\u0126",
8256	"hstrok;": "\u0127",
8257	"HumpDownHump;": "\u224E",
8258	"HumpEqual;": "\u224F",
8259	"hybull;": "\u2043",
8260	"hyphen;": "\u2010",
8261	"Iacute;": "\u00CD",
8262	"Iacute": "\u00CD",
8263	"iacute;": "\u00ED",
8264	"iacute": "\u00ED",
8265	"ic;": "\u2063",
8266	"Icirc;": "\u00CE",
8267	"Icirc": "\u00CE",
8268	"icirc;": "\u00EE",
8269	"icirc": "\u00EE",
8270	"Icy;": "\u0418",
8271	"icy;": "\u0438",
8272	"Idot;": "\u0130",
8273	"IEcy;": "\u0415",
8274	"iecy;": "\u0435",
8275	"iexcl;": "\u00A1",
8276	"iexcl": "\u00A1",
8277	"iff;": "\u21D4",

8278	"ifr;": "\uD835\uDD26",
8279	"Ifr;": "\u2111",
8280	"Igrave;": "\u00CC",
8281	"Igrave": "\u00CC",
8282	"igrave;": "\u00EC",
8283	"igrave": "\u00EC",
8284	"ii;": "\u2148",
8285	"iiiint;": "\u2A0C",
8286	"iiint;": "\u222D",
8287	"iinfin;": "\u29DC",
8288	"iiota;": "\u2129",
8289	"IJlig;": "\u0132",
8290	"ijlig;": "\u0133",
8291	"Imacr;": "\u012A",
8292	"imacr;": "\u012B",
8293	"image;": "\u2111",
8294	"ImaginaryI;": "\u2148",
8295	"imagline;": "\u2110",
8296	"imagpart;": "\u2111",
8297	"imath;": "\u0131",
8298	"Im;": "\u2111",
8299	"imof;": "\u22B7",
8300	"imped;": "\u01B5",
8301	"Implies;": "\u21D2",
8302	"incare;": "\u2105",
8303	"in;": "\u2208",
8304	"infin;": "\u221E",
8305	"infintie;": "\u29DD",
8306	"inodot;": "\u0131",
8307	"intcal;": "\u22BA",
8308	"int;": "\u222B",
8309	"Int;": "\u222C",
8310	"integers;": "\u2124",
8311	"Integral;": "\u222B",
8312	"intercal;": "\u22BA",
8313	"Intersection;": "\u22C2",
8314	"intlarhk;": "\u2A17",
8315	"intprod;": "\u2A3C",
8316	"InvisibleComma;": "\u2063",
8317	"InvisibleTimes;": "\u2062",
8318	"IOcy;": "\u0401",
8319	"iocy;": "\u0451",
8320	"Iogon;": "\u012E",
8321	"iogon;": "\u012F",
8322	"Iopf;": "\uD835\uDD40",
8323	"iopf;": "\uD835\uDD5A",
8324	"Iota;": "\u0399",
8325	"iota;": "\u03B9",
8326	"iprod;": "\u2A3C",
8327	"iquest;": "\u00BF",
8328	"iquest": "\u00BF",
8329	"iscr;": "\uD835\uDCBE",
8330	"Iscr;": "\u2110",
8331	"isin;": "\u2208",
8332	"isindot;": "\u22F5",
8333	"isinE;": "\u22F9",
8334	"isins;": "\u22F4",
8335	"isinsv;": "\u22F3",
8336	"isinv;": "\u2208",
8337	"it;": "\u2062",
8338	"Itilde;": "\u0128",
8339	"itilde;": "\u0129",
8340	"Iukcy;": "\u0406",
8341	"iukcy;": "\u0456",
8342	"Iuml;": "\u00CF",
8343	"Iuml": "\u00CF",
8344	"iuml;": "\u00EF",
8345	"iuml": "\u00EF",
8346	"Jcirc;": "\u0134",
8347	"jcirc;": "\u0135",
8348	"Jcy;": "\u0419",
8349	"jcy;": "\u0439",
8350	"Jfr;": "\uD835\uDD0D",
8351	"jfr;": "\uD835\uDD27",
8352	"jmath;": "\u0237",
8353	"Jopf;": "\uD835\uDD41",
8354	"jopf;": "\uD835\uDD5B",
8355	"Jscr;": "\uD835\uDCA5",
8356	"jscr;": "\uD835\uDCBF",
8357	"Jsercy;": "\u0408",
8358	"jsercy;": "\u0458",
8359	"Jukcy;": "\u0404",
8360	"jukcy;": "\u0454",
8361	"Kappa;": "\u039A",
8362	"kappa;": "\u03BA",
8363	"kappav;": "\u03F0",
8364	"Kcedil;": "\u0136",
8365	"kcedil;": "\u0137",
8366	"Kcy;": "\u041A",
8367	"kcy;": "\u043A",
8368	"Kfr;": "\uD835\uDD0E",
8369	"kfr;": "\uD835\uDD28",
8370	"kgreen;": "\u0138",
8371	"KHcy;": "\u0425",
8372	"khcy;": "\u0445",
8373	"KJcy;": "\u040C",
8374	"kjcy;": "\u045C",
8375	"Kopf;": "\uD835\uDD42",
8376	"kopf;": "\uD835\uDD5C",
8377	"Kscr;": "\uD835\uDCA6",
8378	"kscr;": "\uD835\uDCC0",
8379	"lAarr;": "\u21DA",
8380	"Lacute;": "\u0139",
8381	"lacute;": "\u013A",
8382	"laemptyv;": "\u29B4",
8383	"lagran;": "\u2112",
8384	"Lambda;": "\u039B",
8385	"lambda;": "\u03BB",
8386	"lang;": "\u27E8",
8387	"Lang;": "\u27EA",
8388	"langd;": "\u2991",
8389	"langle;": "\u27E8",
8390	"lap;": "\u2A85",
8391	"Laplacetrf;": "\u2112",
8392	"laquo;": "\u00AB",
8393	"laquo": "\u00AB",
8394	"larrb;": "\u21E4",
8395	"larrbfs;": "\u291F",
8396	"larr;": "\u2190",
8397	"Larr;": "\u219E",
8398	"lArr;": "\u21D0",
8399	"larrfs;": "\u291D",
8400	"larrhk;": "\u21A9",
8401	"larrlp;": "\u21AB",
8402	"larrpl;": "\u2939",
8403	"larrsim;": "\u2973",
8404	"larrtl;": "\u21A2",
8405	"latail;": "\u2919",
8406	"lAtail;": "\u291B",
8407	"lat;": "\u2AAB",
8408	"late;": "\u2AAD",
8409	"lates;": "\u2AAD\uFE00",
8410	"lbarr;": "\u290C",
8411	"lBarr;": "\u290E",
8412	"lbbrk;": "\u2772",
8413	"lbrace;": "\u007B",
8414	"lbrack;": "\u005B",
8415	"lbrke;": "\u298B",
8416	"lbrksld;": "\u298F",
8417	"lbrkslu;": "\u298D",
8418	"Lcaron;": "\u013D",
8419	"lcaron;": "\u013E",
8420	"Lcedil;": "\u013B",
8421	"lcedil;": "\u013C",
8422	"lceil;": "\u2308",
8423	"lcub;": "\u007B",
8424	"Lcy;": "\u041B",
8425	"lcy;": "\u043B",
8426	"ldca;": "\u2936",
8427	"ldquo;": "\u201C",
8428	"ldquor;": "\u201E",
8429	"ldrdhar;": "\u2967",
8430	"ldrushar;": "\u294B",
8431	"ldsh;": "\u21B2",
8432	"le;": "\u2264",
8433	"lE;": "\u2266",
8434	"LeftAngleBracket;": "\u27E8",
8435	"LeftArrowBar;": "\u21E4",
8436	"leftarrow;": "\u2190",
8437	"LeftArrow;": "\u2190",
8438	"Leftarrow;": "\u21D0",
8439	"LeftArrowRightArrow;": "\u21C6",
8440	"leftarrowtail;": "\u21A2",
8441	"LeftCeiling;": "\u2308",
8442	"LeftDoubleBracket;": "\u27E6",
8443	"LeftDownTeeVector;": "\u2961",
8444	"LeftDownVectorBar;": "\u2959",
8445	"LeftDownVector;": "\u21C3",
8446	"LeftFloor;": "\u230A",
8447	"leftharpoondown;": "\u21BD",
8448	"leftharpoonup;": "\u21BC",
8449	"leftleftarrows;": "\u21C7",
8450	"leftrightarrow;": "\u2194",
8451	"LeftRightArrow;": "\u2194",
8452	"Leftrightarrow;": "\u21D4",
8453	"leftrightarrows;": "\u21C6",
8454	"leftrightharpoons;": "\u21CB",
8455	"leftrightsquigarrow;": "\u21AD",
8456	"LeftRightVector;": "\u294E",
8457	"LeftTeeArrow;": "\u21A4",
8458	"LeftTee;": "\u22A3",
8459	"LeftTeeVector;": "\u295A",
8460	"leftthreetimes;": "\u22CB",
8461	"LeftTriangleBar;": "\u29CF",
8462	"LeftTriangle;": "\u22B2",
8463	"LeftTriangleEqual;": "\u22B4",
8464	"LeftUpDownVector;": "\u2951",
8465	"LeftUpTeeVector;": "\u2960",
8466	"LeftUpVectorBar;": "\u2958",
8467	"LeftUpVector;": "\u21BF",
8468	"LeftVectorBar;": "\u2952",
8469	"LeftVector;": "\u21BC",
8470	"lEg;": "\u2A8B",
8471	"leg;": "\u22DA",
8472	"leq;": "\u2264",
8473	"leqq;": "\u2266",
8474	"leqslant;": "\u2A7D",
8475	"lescc;": "\u2AA8",
8476	"les;": "\u2A7D",
8477	"lesdot;": "\u2A7F",
8478	"lesdoto;": "\u2A81",
8479	"lesdotor;": "\u2A83",
8480	"lesg;": "\u22DA\uFE00",
8481	"lesges;": "\u2A93",
8482	"lessapprox;": "\u2A85",
8483	"lessdot;": "\u22D6",
8484	"lesseqgtr;": "\u22DA",
8485	"lesseqqgtr;": "\u2A8B",
8486	"LessEqualGreater;": "\u22DA",
8487	"LessFullEqual;": "\u2266",
8488	"LessGreater;": "\u2276",
8489	"lessgtr;": "\u2276",
8490	"LessLess;": "\u2AA1",
8491	"lesssim;": "\u2272",
8492	"LessSlantEqual;": "\u2A7D",
8493	"LessTilde;": "\u2272",
8494	"lfisht;": "\u297C",
8495	"lfloor;": "\u230A",
8496	"Lfr;": "\uD835\uDD0F",
8497	"lfr;": "\uD835\uDD29",
8498	"lg;": "\u2276",
8499	"lgE;

8499": "\u2A91",
8500	"lHar;": "\u2962",
8501	"lhard;": "\u21BD",
8502	"lharu;": "\u21BC",
8503	"lharul;": "\u296A",
8504	"lhblk;": "\u2584",
8505	"LJcy;": "\u0409",
8506	"ljcy;": "\u0459",
8507	"llarr;": "\u21C7",
8508	"ll;": "\u226A",
8509	"Ll;": "\u22D8",
8510	"llcorner;": "\u231E",
8511	"Lleftarrow;": "\u21DA",
8512	"llhard;": "\u296B",
8513	"lltri;": "\u25FA",
8514	"Lmidot;": "\u013F",
8515	"lmidot;": "\u0140",
8516	"lmoustache;": "\u23B0",
8517	"lmoust;": "\u23B0",
8518	"lnap;": "\u2A89",
8519	"lnapprox;": "\u2A89",
8520	"lne;": "\u2A87",
8521	"lnE;": "\u2268",
8522	"lneq;": "\u2A87",
8523	"lneqq;": "\u2268",
8524	"lnsim;": "\u22E6",
8525	"loang;": "\u27EC",
8526	"loarr;": "\u21FD",
8527	"lobrk;": "\u27E6",
8528	"longleftarrow;": "\u27F5",
8529	"LongLeftArrow;": "\u27F5",
8530	"Longleftarrow;": "\u27F8",
8531	"longleftrightarrow;": "\u27F7",
8532	"LongLeftRightArrow;": "\u27F7",
8533	"Longleftrightarrow;": "\u27FA",
8534	"longmapsto;": "\u27FC",
8535	"longrightarrow;": "\u27F6",
8536	"LongRightArrow;": "\u27F6",
8537	"Longrightarrow;": "\u27F9",
8538	"looparrowleft;": "\u21AB",
8539	"looparrowright;": "\u21AC",
8540	"lopar;": "\u2985",
8541	"Lopf;": "\uD835\uDD43",
8542	"lopf;": "\uD835\uDD5D",
8543	"loplus;": "\u2A2D",
8544	"lotimes;": "\u2A34",
8545	"lowast;": "\u2217",
8546	"lowbar;": "\u005F",
8547	"LowerLeftArrow;": "\u2199",
8548	"LowerRightArrow;": "\u2198",
8549	"loz;": "\u25CA",
8550	"lozenge;": "\u25CA",
8551	"lozf;": "\u29EB",
8552	"lpar;": "\u0028",
8553	"lparlt;": "\u2993",
8554	"lrarr;": "\u21C6",
8555	"lrcorner;": "\u231F",
8556	"lrhar;": "\u21CB",
8557	"lrhard;": "\u296D",
8558	"lrm;": "\u200E",
8559	"lrtri;": "\u22BF",
8560	"lsaquo;": "\u2039",
8561	"lscr;": "\uD835\uDCC1",
8562	"Lscr;": "\u2112",
8563	"lsh;": "\u21B0",
8564	"Lsh;": "\u21B0",
8565	"lsim;": "\u2272",
8566	"lsime;": "\u2A8D",
8567	"lsimg;": "\u2A8F",
8568	"lsqb;": "\u005B",
8569	"lsquo;": "\u2018",
8570	"lsquor;": "\u201A",
8571	"Lstrok;": "\u0141",
8572	"lstrok;": "\u0142",
8573	"ltcc;": "\u2AA6",
8574	"ltcir;": "\u2A79",
8575	"lt;": "\u003C",
8576	"lt": "\u003C",
8577	"LT;": "\u003C",
8578	"LT": "\u003C",
8579	"Lt;": "\u226A",
8580	"ltdot;": "\u22D6",
8581	"lthree;": "\u22CB",
8582	"ltimes;": "\u22C9",
8583	"ltlarr;": "\u2976",
8584	"ltquest;": "\u2A7B",
8585	"ltri;": "\u25C3",
8586	"ltrie;": "\u22B4",
8587	"ltrif;": "\u25C2",
8588	"ltrPar;": "\u2996",
8589	"lurdshar;": "\u294A",
8590	"luruhar;": "\u2966",
8591	"lvertneqq;": "\u2268\uFE00",
8592	"lvnE;": "\u2268\uFE00",
8593	"macr;": "\u00AF",
8594	"macr": "\u00AF",
8595	"male;": "\u2642",
8596	"malt;": "\u2720",
8597	"maltese;": "\u2720",
8598	"Map;": "\u2905",
8599	"map;": "\u21A6",
8600	"mapsto;": "\u21A6",
8601	"mapstodown;": "\u21A7",
8602	"mapstoleft;": "\u21A4",
8603	"mapstoup;": "\u21A5",
8604	"marker;": "\u25AE",
8605	"mcomma;": "\u2A29",
8606	"Mcy;": "\u041C",
8607	"mcy;": "\u043C",
8608	"mdash;": "\u2014",
8609	"mDDot;": "\u223A",
8610	"measuredangle;": "\u2221",
8611	"MediumSpace;": "\u205F",
8612	"Mellintrf;": "\u2133",
8613	"Mfr;": "\uD835\uDD10",
8614	"mfr;": "\uD835\uDD2A",
8615	"mho;": "\u2127",
8616	"micro;": "\u00B5",
8617	"micro": "\u00B5",
8618	"midast;": "\u002A",
8619	"midcir;": "\u2AF0",
8620	"mid;": "\u2223",
8621	"middot;": "\u00B7",
8622	"middot": "\u00B7",
8623	"minusb;": "\u229F",
8624	"minus;": "\u2212",
8625	"minusd;": "\u2238",
8626	"minusdu;": "\u2A2A",
8627	"MinusPlus;": "\u2213",
8628	"mlcp;": "\u2ADB",
8629	"mldr;": "\u2026",
8630	"mnplus;": "\u2213",
8631	"models;": "\u22A7",
8632	"Mopf;": "\uD835\uDD44",
8633	"mopf;": "\uD835\uDD5E",
8634	"mp;": "\u2213",
8635	"mscr;": "\uD835\uDCC2",
8636	"Mscr;": "\u2133",
8637	"mstpos;": "\u223E",
8638	"Mu;": "\u039C",
8639	"mu;": "\u03BC",
8640	"multimap;": "\u22B8",
8641	"mumap;": "\u22B8",
8642	"nabla;": "\u2207",
8643	"Nacute;": "\u0143",
8644	"nacute;": "\u0144",
8645	"nang;": "\u2220\u20D2",
8646	"nap;": "\u2249",
8647	"napE;": "\u2A70\u0338",
8648	"napid;": "\u224B\u0338",
8649	"napos;": "\u0149",
8650	"napprox;": "\u2249",
8651	"natural;": "\u266E",
8652	"naturals;": "\u2115",
8653	"natur;": "\u266E",
8654	"nbsp;": "\u00A0",
8655	"nbsp": "\u00A0",
8656	"nbump;": "\u224E\u0338",
8657	"nbumpe;": "\u224F\u0338",
8658	"ncap;": "\u2A43",
8659	"Ncaron;": "\u0147",
8660	"ncaron;": "\u0148",
8661	"Ncedil;": "\u0145",
8662	"ncedil;": "\u0146",
8663	"ncong;": "\u2247",
8664	"ncongdot;": "\u2A6D\u0338",
8665	"ncup;": "\u2A42",
8666	"Ncy;": "\u041D",
8667	"ncy;": "\u043D",
8668	"ndash;": "\u2013",
8669	"nearhk;": "\u2924",
8670	"nearr;": "\u2197",
8671	"neArr;": "\u21D7",
8672	"nearrow;": "\u2197",
8673	"ne;": "\u2260",
8674	"nedot;": "\u2250\u0338",
8675	"NegativeMediumSpace;": "\u200B",
8676	"NegativeThickSpace;": "\u200B",
8677	"NegativeThinSpace;": "\u200B",
8678	"NegativeVeryThinSpace;": "\u200B",
8679	"nequiv;": "\u2262",
8680	"nesear;": "\u2928",
8681	"nesim;": "\u2242\u0338",
8682	"NestedGreaterGreater;": "\u226B",
8683	"NestedLessLess;": "\u226A",
8684	"NewLine;": "\u000A",
8685	"nexist;": "\u2204",
8686	"nexists;": "\u2204",
8687	"Nfr;": "\uD835\uDD11",
8688	"nfr;": "\uD835\uDD2B",
8689	"ngE;": "\u2267\u0338",
8690	"nge;": "\u2271",
8691	"ngeq;": "\u2271",
8692	"ngeqq;": "\u2267\u0338",
8693	"ngeqslant;": "\u2A7E\u0338",
8694	"nges;": "\u2A7E\u0338",
8695	"nGg;": "\u22D9\u0338",
8696	"ngsim;": "\u2275",
8697	"nGt;": "\u226B\u20D2",
8698	"ngt;": "\u226F",
8699	"ngtr;": "\u226F",
8700	"nGtv;": "\u226B\u0338",
8701	"nharr;": "\u21AE",
8702	"nhArr;": "\u21CE",
8703	"nhpar;": "\u2AF2",
8704	"ni;": "\u220B",
8705	"nis;": "\u22FC",
8706	"nisd;": "\u22FA",
8707	"niv;": "\u220B",
8708	"NJcy;": "\u040A",
8709	"njcy;": "\u045A",
8710	"nlarr;": "\u219A",
8711	"nlArr;": "\u21CD",
8712	"nldr;": "\u2025",
8713	"nlE;": "\u2266\u0338",
8714	"nle;": "\u2270",
8715	"nleftarrow;": "\u219A",
8716	"nLeftarrow;": "\u21CD",
8717	"nleftrightarrow;": "\u21AE",
8718	"nLeftrightarrow;": "\u21CE",
8719	"nleq;": "\u2270",
8720	"nleqq;": "\u2266\u0338",
8721	"nleqslant;": "\u2A7D\u0338",
8722	"nles;": "\u2A7D\u0338",
8723	"nless;": "\u226E",
8724	"nLl;": "\u22D8\u0338",
8725	"nlsim;": "\u2274",
8726	"nLt;": "\u226A\u20D2",
8727	"nlt;": "\u226E",
8728	"nltri;": "\u22EA",
8729	"nltrie;": "\u22EC",
8730	"nLtv;": "\u226A\u0338",
8731	"nmid;": "\u2224",
8732	"NoBreak;": "\u2060",
8733	"NonBreakingSpace;": "\u00A0",
8734	"nopf;": "\uD835\uDD5F",
8735	"Nopf;": "\u2115",
8736	"Not;": "\u2AEC",
8737	"not;": "\u00AC",
8738	"not": "\u00AC",
8739	"NotCongruent;": "\u2262",
8740	"NotCupCap;": "\u226D",
8741	"NotDoubleVerticalBar;": "\u2226",
8742	"NotElement;": "\u2209",
8743	"NotEqual;": "\u2260",
8744	"NotEqualTilde;": "\u2242\u0338",
8745	"NotExists;": "\u2204",
8746	"NotGreater;": "\u226F",
8747	"NotGreaterEqual;": "\u2271",
8748	"NotGreaterFullEqual;": "\u2267\u0338",
8749	"NotGreaterGreater;": "\u226B\u0338",
8750	"NotGreaterLess;": "\u2279",
8751	"NotGreaterSlantEqual;": "\u2A7E\u0338",
8752	"NotGreaterTilde;": "\u2275",
8753	"NotHumpDownHump;": "\u224E\u0338",
8754	"NotHumpEqual;": "\u224F\u0338",
8755	"notin;": "\u2209",
8756	"notindot;": "\u22F5\u0338",
8757	"notinE;": "\u22F9\u0338",
8758	"notinva;": "\u2209",
8759	"notinvb;": "\u22F7",
8760	"notinvc;": "\u22F6",
8761	"NotLeftTriangleBar;": "\u29CF\u0338",
8762	"NotLeftTriangle;": "\u22EA",
8763	"NotLeftTriangleEqual;": "\u22EC",
8764	"NotLess;": "\u226E",
8765	"NotLessEqual;": "\u2270",
8766	"NotLessGreater;": "\u2278",
8767	"NotLessLess;": "\u226A\u0338",
8768	"NotLessSlantEqual;": "\u2A7D\u0338",
8769	"NotLessTilde;": "\u2274",
8770	"NotNestedGreaterGreater;": "\u2AA2\u0338",
8771	"NotNestedLessLess;": "\u2AA1\u0338",
8772	"notni;": "\u220C",
8773	"notniva;": "\u220C",
8774	"notnivb;": "\u22FE",
8775	"notnivc;": "\u22FD",
8776	"NotPrecedes;": "\u2280",
8777	"NotPrecedesEqual;": "\u2AAF\u0338",
8778	"NotPrecedesSlantEqual;": "\u22E0",
8779	"NotReverseElement;": "\u220C",
8780	"NotRightTriangleBar;": "\u29D0\u0338",
8781	"NotRightTriangle;": "\u22EB",
8782	"NotRightTriangleEqual;": "\u22ED",
8783	"NotSquareSubset;": "\u228F\u0338",
8784	"NotSquareSubsetEqual;": "\u22E2",
8785	"NotSquareSuperset;": "\u2290\u0338",
8786	"NotSquareSupersetEqual;": "\u22E3",
8787	"NotSubset;": "\u2282\u20D2",
8788	"NotSubsetEqual;": "\u2288",
8789	"NotSucceeds;": "\u2281",
8790	"NotSucceedsEqual;": "\u2AB0\u0338",
8791	"NotSucceedsSlantEqual;": "\u22E1",
8792	"NotSucceedsTilde;": "\u227F\u0338",
8793	"NotSuperset;": "\u2283\u20D2",
8794	"NotSupersetEqual;": "\u2289",
8795	"NotTilde;": "\u2241",
8796	"NotTildeEqual;": "\u2244",
8797	"NotTildeFullEqual;": "\u2247",
8798	"NotTildeTilde;": "\u2249",
8799	"NotVerticalBar;": "\u2224",
8800	"nparallel;": "\u2226",
8801	"npar;": "\u2226",
8802	"nparsl;": "\u2AFD\u20E5",
8803	"npart;

8803": "\u2202\u0338",
8804	"npolint;": "\u2A14",
8805	"npr;": "\u2280",
8806	"nprcue;": "\u22E0",
8807	"nprec;": "\u2280",
8808	"npreceq;": "\u2AAF\u0338",
8809	"npre;": "\u2AAF\u0338",
8810	"nrarrc;": "\u2933\u0338",
8811	"nrarr;": "\u219B",
8812	"nrArr;": "\u21CF",
8813	"nrarrw;": "\u219D\u0338",
8814	"nrightarrow;": "\u219B",
8815	"nRightarrow;": "\u21CF",
8816	"nrtri;": "\u22EB",
8817	"nrtrie;": "\u22ED",
8818	"nsc;": "\u2281",
8819	"nsccue;": "\u22E1",
8820	"nsce;": "\u2AB0\u0338",
8821	"Nscr;": "\uD835\uDCA9",
8822	"nscr;": "\uD835\uDCC3",
8823	"nshortmid;": "\u2224",
8824	"nshortparallel;": "\u2226",
8825	"nsim;": "\u2241",
8826	"nsime;": "\u2244",
8827	"nsimeq;": "\u2244",
8828	"nsmid;": "\u2224",
8829	"nspar;": "\u2226",
8830	"nsqsube;": "\u22E2",
8831	"nsqsupe;": "\u22E3",
8832	"nsub;": "\u2284",
8833	"nsubE;": "\u2AC5\u0338",
8834	"nsube;": "\u2288",
8835	"nsubset;": "\u2282\u20D2",
8836	"nsubseteq;": "\u2288",
8837	"nsubseteqq;": "\u2AC5\u0338",
8838	"nsucc;": "\u2281",
8839	"nsucceq;": "\u2AB0\u0338",
8840	"nsup;": "\u2285",
8841	"nsupE;": "\u2AC6\u0338",
8842	"nsupe;": "\u2289",
8843	"nsupset;": "\u2283\u20D2",
8844	"nsupseteq;": "\u2289",
8845	"nsupseteqq;": "\u2AC6\u0338",
8846	"ntgl;": "\u2279",
8847	"Ntilde;": "\u00D1",
8848	"Ntilde": "\u00D1",
8849	"ntilde;": "\u00F1",
8850	"ntilde": "\u00F1",
8851	"ntlg;": "\u2278",
8852	"ntriangleleft;": "\u22EA",
8853	"ntrianglelefteq;": "\u22EC",
8854	"ntriangleright;": "\u22EB",
8855	"ntrianglerighteq;": "\u22ED",
8856	"Nu;": "\u039D",
8857	"nu;": "\u03BD",
8858	"num;": "\u0023",
8859	"numero;": "\u2116",
8860	"numsp;": "\u2007",
8861	"nvap;": "\u224D\u20D2",
8862	"nvdash;": "\u22AC",
8863	"nvDash;": "\u22AD",
8864	"nVdash;": "\u22AE",
8865	"nVDash;": "\u22AF",
8866	"nvge;": "\u2265\u20D2",
8867	"nvgt;": "\u003E\u20D2",
8868	"nvHarr;": "\u2904",
8869	"nvinfin;": "\u29DE",
8870	"nvlArr;": "\u2902",
8871	"nvle;": "\u2264\u20D2",
8872	"nvlt;": "\u003C\u20D2",
8873	"nvltrie;": "\u22B4\u20D2",
8874	"nvrArr;": "\u2903",
8875	"nvrtrie;": "\u22B5\u20D2",
8876	"nvsim;": "\u223C\u20D2",
8877	"nwarhk;": "\u2923",
8878	"nwarr;": "\u2196",
8879	"nwArr;": "\u21D6",
8880	"nwarrow;": "\u2196",
8881	"nwnear;": "\u2927",
8882	"Oacute;": "\u00D3",
8883	"Oacute": "\u00D3",
8884	"oacute;": "\u00F3",
8885	"oacute": "\u00F3",
8886	"oast;": "\u229B",
8887	"Ocirc;": "\u00D4",
8888	"Ocirc": "\u00D4",
8889	"ocirc;": "\u00F4",
8890	"ocirc": "\u00F4",
8891	"ocir;": "\u229A",
8892	"Ocy;": "\u041E",
8893	"ocy;": "\u043E",
8894	"odash;": "\u229D",
8895	"Odblac;": "\u0150",
8896	"odblac;": "\u0151",
8897	"odiv;": "\u2A38",
8898	"odot;": "\u2299",
8899	"odsold;": "\u29BC",
8900	"OElig;": "\u0152",
8901	"oelig;": "\u0153",
8902	"ofcir;": "\u29BF",
8903	"Ofr;": "\uD835\uDD12",
8904	"ofr;": "\uD835\uDD2C",
8905	"ogon;": "\u02DB",
8906	"Ograve;": "\u00D2",
8907	"Ograve": "\u00D2",
8908	"ograve;": "\u00F2",
8909	"ograve": "\u00F2",
8910	"ogt;": "\u29C1",
8911	"ohbar;": "\u29B5",
8912	"ohm;": "\u03A9",
8913	"oint;": "\u222E",
8914	"olarr;": "\u21BA",
8915	"olcir;": "\u29BE",
8916	"olcross;": "\u29BB",
8917	"oline;": "\u203E",
8918	"olt;": "\u29C0",
8919	"Omacr;": "\u014C",
8920	"omacr;": "\u014D",
8921	"Omega;": "\u03A9",
8922	"omega;": "\u03C9",
8923	"Omicron;": "\u039F",
8924	"omicron;": "\u03BF",
8925	"omid;": "\u29B6",
8926	"ominus;": "\u2296",
8927	"Oopf;": "\uD835\uDD46",
8928	"oopf;": "\uD835\uDD60",
8929	"opar;": "\u29B7",
8930	"OpenCurlyDoubleQuote;": "\u201C",
8931	"OpenCurlyQuote;": "\u2018",
8932	"operp;": "\u29B9",
8933	"oplus;": "\u2295",
8934	"orarr;": "\u21BB",
8935	"Or;": "\u2A54",
8936	"or;": "\u2228",
8937	"ord;": "\u2A5D",
8938	"order;": "\u2134",
8939	"orderof;": "\u2134",
8940	"ordf;": "\u00AA",
8941	"ordf": "\u00AA",
8942	"ordm;": "\u00BA",
8943	"ordm": "\u00BA",
8944	"origof;": "\u22B6",
8945	"oror;": "\u2A56",
8946	"orslope;": "\u2A57",
8947	"orv;": "\u2A5B",
8948	"oS;": "\u24C8",
8949	"Oscr;": "\uD835\uDCAA",
8950	"oscr;": "\u2134",
8951	"Oslash;": "\u00D8",
8952	"Oslash": "\u00D8",
8953	"oslash;": "\u00F8",
8954	"oslash": "\u00F8",
8955	"osol;": "\u2298",
8956	"Otilde;": "\u00D5",
8957	"Otilde": "\u00D5",
8958	"otilde;": "\u00F5",
8959	"otilde": "\u00F5",
8960	"otimesas;": "\u2A36",
8961	"Otimes;": "\u2A37",
8962	"otimes;": "\u2297",
8963	"Ouml;": "\u00D6",
8964	"Ouml": "\u00D6",
8965	"ouml;": "\u00F6",
8966	"ouml": "\u00F6",
8967	"ovbar;": "\u233D",
8968	"OverBar;": "\u203E",
8969	"OverBrace;": "\u23DE",
8970	"OverBracket;": "\u23B4",
8971	"OverParenthesis;": "\u23DC",
8972	"para;": "\u00B6",
8973	"para": "\u00B6",
8974	"parallel;": "\u2225",
8975	"par;": "\u2225",
8976	"parsim;": "\u2AF3",
8977	"parsl;": "\u2AFD",
8978	"part;": "\u2202",
8979	"PartialD;": "\u2202",
8980	"Pcy;": "\u041F",
8981	"pcy;": "\u043F",
8982	"percnt;": "\u0025",
8983	"period;": "\u002E",
8984	"permil;": "\u2030",
8985	"perp;": "\u22A5",
8986	"pertenk;": "\u2031",
8987	"Pfr;": "\uD835\uDD13",
8988	"pfr;": "\uD835\uDD2D",
8989	"Phi;": "\u03A6",
8990	"phi;": "\u03C6",
8991	"phiv;": "\u03D5",
8992	"phmmat;": "\u2133",
8993	"phone;": "\u260E",
8994	"Pi;": "\u03A0",
8995	"pi;": "\u03C0",
8996	"pitchfork;": "\u22D4",
8997	"piv;": "\u03D6",
8998	"planck;": "\u210F",
8999	"planckh;": "\u210E",
9000	"plankv;": "\u210F",
9001	"plusacir;": "\u2A23",
9002	"plusb;": "\u229E",
9003	"pluscir;": "\u2A22",
9004	"plus;": "\u002B",
9005	"plusdo;": "\u2214",
9006	"plusdu;": "\u2A25",
9007	"pluse;": "\u2A72",
9008	"PlusMinus;": "\u00B1",
9009	"plusmn;": "\u00B1",
9010	"plusmn": "\u00B1",
9011	"plussim;": "\u2A26",
9012	"plustwo;": "\u2A27",
9013	"pm;": "\u00B1",
9014	"Poincareplane;": "\u210C",
9015	"pointint;": "\u2A15",
9016	"popf;": "\uD835\uDD61",
9017	"Popf;": "\u2119",
9018	"pound;": "\u00A3",
9019	"pound": "\u00A3",
9020	"prap;": "\u2AB7",
9021	"Pr;": "\u2ABB",
9022	"pr;": "\u227A",
9023	"prcue;": "\u227C",
9024	"precapprox;": "\u2AB7",
9025	"prec;": "\u227A",
9026	"preccurlyeq;": "\u227C",
9027	"Precedes;": "\u227A",
9028	"PrecedesEqual;": "\u2AAF",
9029	"PrecedesSlantEqual;": "\u227C",
9030	"PrecedesTilde;": "\u227E",
9031	"preceq;": "\u2AAF",
9032	"precnapprox;": "\u2AB9",
9033	"precneqq;": "\u2AB5",
9034	"precnsim;": "\u22E8",
9035	"pre;": "\u2AAF",
9036	"prE;": "\u2AB3",
9037	"precsim;": "\u227E",
9038	"prime;": "\u2032",
9039	"Prime;": "\u2033",
9040	"primes;": "\u2119",
9041	"prnap;": "\u2AB9",
9042	"prnE;": "\u2AB5",
9043	"prnsim;": "\u22E8",
9044	"prod;": "\u220F",
9045	"Product;": "\u220F",
9046	"profalar;": "\u232E",
9047	"profline;": "\u2312",
9048	"profsurf;": "\u2313",
9049	"prop;": "\u221D",
9050	"Proportional;": "\u221D",
9051	"Proportion;": "\u2237",
9052	"propto;": "\u221D",
9053	"prsim;": "\u227E",
9054	"prurel;": "\u22B0",
9055	"Pscr;": "\uD835\uDCAB",
9056	"pscr;": "\uD835\uDCC5",
9057	"Psi;": "\u03A8",
9058	"psi;": "\u03C8",
9059	"puncsp;": "\u2008",
9060	"Qfr;": "\uD835\uDD14",
9061	"qfr;": "\uD835\uDD2E",
9062	"qint;": "\u2A0C",
9063	"qopf;": "\uD835\uDD62",
9064	"Qopf;": "\u211A",
9065	"qprime;": "\u2057",
9066	"Qscr;": "\uD835\uDCAC",
9067	"qscr;": "\uD835\uDCC6",
9068	"quaternions;": "\u210D",
9069	"quatint;": "\u2A16",
9070	"quest;": "\u003F",
9071	"questeq;": "\u225F",
9072	"quot;": "\u0022",
9073	"quot": "\u0022",
9074	"QUOT;": "\u0022",
9075	"QUOT": "\u0022",
9076	"rAarr;": "\u21DB",
9077	"race;": "\u223D\u0331",
9078	"Racute;": "\u0154",
9079	"racute;": "\u0155",
9080	"radic;": "\u221A",
9081	"raemptyv;": "\u29B3",
9082	"rang;": "\u27E9",
9083	"Rang;": "\u27EB",
9084	"rangd;": "\u2992",
9085	"range;": "\u29A5",
9086	"rangle;": "\u27E9",
9087	"raquo;": "\u00BB",
9088	"raquo": "\u00BB",
9089	"rarrap;": "\u2975",
9090	"rarrb;": "\u21E5",

9091	"rarrbfs;": "\u2920",
9092	"rarrc;": "\u2933",
9093	"rarr;": "\u2192",
9094	"Rarr;": "\u21A0",
9095	"rArr;": "\u21D2",
9096	"rarrfs;": "\u291E",
9097	"rarrhk;": "\u21AA",
9098	"rarrlp;": "\u21AC",
9099	"rarrpl;": "\u2945",
9100	"rarrsim;": "\u2974",
9101	"Rarrtl;": "\u2916",
9102	"rarrtl;": "\u21A3",
9103	"rarrw;": "\u219D",
9104	"ratail;": "\u291A",
9105	"rAtail;": "\u291C",
9106	"ratio;": "\u2236",
9107	"rationals;": "\u211A",
9108	"rbarr;": "\u290D",
9109	"rBarr;": "\u290F",
9110	"RBarr;": "\u2910",
9111	"rbbrk;": "\u2773",
9112	"rbrace;": "\u007D",
9113	"rbrack;": "\u005D",
9114	"rbrke;": "\u298C",
9115	"rbrksld;": "\u298E",
9116	"rbrkslu;": "\u2990",
9117	"Rcaron;": "\u0158",
9118	"rcaron;": "\u0159",
9119	"Rcedil;": "\u0156",
9120	"rcedil;": "\u0157",
9121	"rceil;": "\u2309",
9122	"rcub;": "\u007D",
9123	"Rcy;": "\u0420",
9124	"rcy;": "\u0440",
9125	"rdca;": "\u2937",
9126	"rdldhar;": "\u2969",
9127	"rdquo;": "\u201D",
9128	"rdquor;": "\u201D",
9129	"rdsh;": "\u21B3",
9130	"real;": "\u211C",
9131	"realine;": "\u211B",
9132	"realpart;": "\u211C",
9133	"reals;": "\u211D",
9134	"Re;": "\u211C",
9135	"rect;": "\u25AD",
9136	"reg;": "\u00AE",
9137	"reg": "\u00AE",
9138	"REG;": "\u00AE",
9139	"REG": "\u00AE",
9140	"ReverseElement;": "\u220B",
9141	"ReverseEquilibrium;": "\u21CB",
9142	"ReverseUpEquilibrium;": "\u296F",
9143	"rfisht;": "\u297D",
9144	"rfloor;": "\u230B",
9145	"rfr;": "\uD835\uDD2F",
9146	"Rfr;": "\u211C",
9147	"rHar;": "\u2964",
9148	"rhard;": "\u21C1",
9149	"rharu;": "\u21C0",
9150	"rharul;": "\u296C",
9151	"Rho;": "\u03A1",
9152	"rho;": "\u03C1",
9153	"rhov;": "\u03F1",
9154	"RightAngleBracket;": "\u27E9",
9155	"RightArrowBar;": "\u21E5",
9156	"rightarrow;": "\u2192",
9157	"RightArrow;": "\u2192",
9158	"Rightarrow;": "\u21D2",
9159	"RightArrowLeftArrow;": "\u21C4",
9160	"rightarrowtail;": "\u21A3",
9161	"RightCeiling;": "\u2309",
9162	"RightDoubleBracket;": "\u27E7",
9163	"RightDownTeeVector;": "\u295D",
9164	"RightDownVectorBar;": "\u2955",
9165	"RightDownVector;": "\u21C2",
9166	"RightFloor;": "\u230B",
9167	"rightharpoondown;": "\u21C1",
9168	"rightharpoonup;": "\u21C0",
9169	"rightleftarrows;": "\u21C4",
9170	"rightleftharpoons;": "\u21CC",
9171	"rightrightarrows;": "\u21C9",
9172	"rightsquigarrow;": "\u219D",
9173	"RightTeeArrow;": "\u21A6",
9174	"RightTee;": "\u22A2",
9175	"RightTeeVector;": "\u295B",
9176	"rightthreetimes;": "\u22CC",
9177	"RightTriangleBar;": "\u29D0",
9178	"RightTriangle;": "\u22B3",
9179	"RightTriangleEqual;": "\u22B5",
9180	"RightUpDownVector;": "\u294F",
9181	"RightUpTeeVector;": "\u295C",
9182	"RightUpVectorBar;": "\u2954",
9183	"RightUpVector;": "\u21BE",
9184	"RightVectorBar;": "\u2953",
9185	"RightVector;": "\u21C0",
9186	"ring;": "\u02DA",
9187	"risingdotseq;": "\u2253",
9188	"rlarr;": "\u21C4",
9189	"rlhar;": "\u21CC",
9190	"rlm;": "\u200F",
9191	"rmoustache;": "\u23B1",
9192	"rmoust;": "\u23B1",
9193	"rnmid;": "\u2AEE",
9194	"roang;": "\u27ED",
9195	"roarr;": "\u21FE",
9196	"robrk;": "\u27E7",
9197	"ropar;": "\u2986",
9198	"ropf;": "\uD835\uDD63",
9199	"Ropf;": "\u211D",
9200	"roplus;": "\u2A2E",
9201	"rotimes;": "\u2A35",
9202	"RoundImplies;": "\u2970",
9203	"rpar;": "\u0029",
9204	"rpargt;": "\u2994",
9205	"rppolint;": "\u2A12",
9206	"rrarr;": "\u21C9",
9207	"Rrightarrow;": "\u21DB",
9208	"rsaquo;": "\u203A",
9209	"rscr;": "\uD835\uDCC7",
9210	"Rscr;": "\u211B",
9211	"rsh;": "\u21B1",
9212	"Rsh;": "\u21B1",
9213	"rsqb;": "\u005D",
9214	"rsquo;": "\u2019",
9215	"rsquor;": "\u2019",
9216	"rthree;": "\u22CC",
9217	"rtimes;": "\u22CA",
9218	"rtri;": "\u25B9",
9219	"rtrie;": "\u22B5",
9220	"rtrif;": "\u25B8",
9221	"rtriltri;": "\u29CE",
9222	"RuleDelayed;": "\u29F4",
9223	"ruluhar;": "\u2968",
9224	"rx;": "\u211E",
9225	"Sacute;": "\u015A",
9226	"sacute;": "\u015B",
9227	"sbquo;": "\u201A",
9228	"scap;": "\u2AB8",
9229	"Scaron;": "\u0160",
9230	"scaron;": "\u0161",
9231	"Sc;": "\u2ABC",
9232	"sc;": "\u227B",
9233	"sccue;": "\u227D",
9234	"sce;": "\u2AB0",
9235	"scE;": "\u2AB4",
9236	"Scedil;": "\u015E",
9237	"scedil;": "\u015F",
9238	"Scirc;": "\u015C",
9239	"scirc;": "\u015D",
9240	"scnap;": "\u2ABA",
9241	"scnE;": "\u2AB6",
9242	"scnsim;": "\u22E9",
9243	"scpolint;": "\u2A13",
9244	"scsim;": "\u227F",
9245	"Scy;": "\u0421",
9246	"scy;": "\u0441",
9247	"sdotb;": "\u22A1",
9248	"sdot;": "\u22C5",
9249	"sdote;": "\u2A66",
9250	"searhk;": "\u2925",
9251	"searr;": "\u2198",
9252	"seArr;": "\u21D8",
9253	"searrow;": "\u2198",
9254	"sect;": "\u00A7",
9255	"sect": "\u00A7",
9256	"semi;": "\u003B",
9257	"seswar;": "\u2929",
9258	"setminus;": "\u2216",
9259	"setmn;": "\u2216",
9260	"sext;": "\u2736",
9261	"Sfr;": "\uD835\uDD16",
9262	"sfr;": "\uD835\uDD30",
9263	"sfrown;": "\u2322",
9264	"sharp;": "\u266F",
9265	"SHCHcy;": "\u0429",
9266	"shchcy;": "\u0449",
9267	"SHcy;": "\u0428",
9268	"shcy;": "\u0448",
9269	"ShortDownArrow;": "\u2193",
9270	"ShortLeftArrow;

9270": "\u2190",
9271	"shortmid;": "\u2223",
9272	"shortparallel;": "\u2225",
9273	"ShortRightArrow;": "\u2192",
9274	"ShortUpArrow;": "\u2191",
9275	"shy;": "\u00AD",
9276	"shy": "\u00AD",
9277	"Sigma;": "\u03A3",
9278	"sigma;": "\u03C3",
9279	"sigmaf;": "\u03C2",
9280	"sigmav;": "\u03C2",
9281	"sim;": "\u223C",
9282	"simdot;": "\u2A6A",
9283	"sime;": "\u2243",
9284	"simeq;": "\u2243",
9285	"simg;": "\u2A9E",
9286	"simgE;": "\u2AA0",
9287	"siml;": "\u2A9D",
9288	"simlE;": "\u2A9F",
9289	"simne;": "\u2246",
9290	"simplus;": "\u2A24",
9291	"simrarr;": "\u2972",
9292	"slarr;": "\u2190",
9293	"SmallCircle;": "\u2218",
9294	"smallsetminus;": "\u2216",
9295	"smashp;": "\u2A33",
9296	"smeparsl;": "\u29E4",
9297	"smid;": "\u2223",
9298	"smile;": "\u2323",
9299	"smt;": "\u2AAA",
9300	"smte;": "\u2AAC",
9301	"smtes;": "\u2AAC\uFE00",
9302	"SOFTcy;": "\u042C",
9303	"softcy;": "\u044C",
9304	"solbar;": "\u233F",
9305	"solb;": "\u29C4",
9306	"sol;": "\u002F",
9307	"Sopf;": "\uD835\uDD4A",
9308	"sopf;": "\uD835\uDD64",
9309	"spades;": "\u2660",
9310	"spadesuit;": "\u2660",
9311	"spar;": "\u2225",
9312	"sqcap;": "\u2293",
9313	"sqcaps;": "\u2293\uFE00",
9314	"sqcup;": "\u2294",
9315	"sqcups;": "\u2294\uFE00",
9316	"Sqrt;": "\u221A",
9317	"sqsub;": "\u228F",
9318	"sqsube;": "\u2291",
9319	"sqsubset;": "\u228F",
9320	"sqsubseteq;": "\u2291",
9321	"sqsup;": "\u2290",
9322	"sqsupe;": "\u2292",
9323	"sqsupset;": "\u2290",
9324	"sqsupseteq;": "\u2292",
9325	"square;": "\u25A1",
9326	"Square;": "\u25A1",
9327	"SquareIntersection;": "\u2293",
9328	"SquareSubset;": "\u228F",
9329	"SquareSubsetEqual;": "\u2291",
9330	"SquareSuperset;": "\u2290",
9331	"SquareSupersetEqual;": "\u2292",
9332	"SquareUnion;": "\u2294",
9333	"squarf;": "\u25AA",
9334	"squ;": "\u25A1",
9335	"squf;": "\u25AA",
9336	"srarr;": "\u2192",
9337	"Sscr;": "\uD835\uDCAE",
9338	"sscr;": "\uD835\uDCC8",
9339	"ssetmn;": "\u2216",
9340	"ssmile;": "\u2323",
9341	"sstarf;": "\u22C6",
9342	"Star;": "\u22C6",
9343	"star;": "\u2606",
9344	"starf;": "\u2605",
9345	"straightepsilon;": "\u03F5",
9346	"straightphi;": "\u03D5",
9347	"strns;": "\u00AF",
9348	"sub;": "\u2282",
9349	"Sub;": "\u22D0",
9350	"subdot;": "\u2ABD",
9351	"subE;": "\u2AC5",
9352	"sube;": "\u2286",
9353	"subedot;": "\u2AC3",
9354	"submult;": "\u2AC1",
9355	"subnE;": "\u2ACB",
9356	"subne;": "\u228A",
9357	"subplus;": "\u2ABF",
9358	"subrarr;": "\u2979",
9359	"subset;": "\u2282",
9360	"Subset;": "\u22D0",
9361	"subseteq;": "\u2286",
9362	"subseteqq;": "\u2AC5",
9363	"SubsetEqual;": "\u2286",
9364	"subsetneq;": "\u228A",
9365	"subsetneqq;": "\u2ACB",
9366	"subsim;": "\u2AC7",
9367	"subsub;": "\u2AD5",
9368	"subsup;": "\u2AD3",
9369	"succapprox;": "\u2AB8",
9370	"succ;": "\u227B",
9371	"succcurlyeq;": "\u227D",
9372	"Succeeds;": "\u227B",
9373	"SucceedsEqual;": "\u2AB0",
9374	"SucceedsSlantEqual;": "\u227D",
9375	"SucceedsTilde;": "\u227F",
9376	"succeq;": "\u2AB0",
9377	"succnapprox;": "\u2ABA",
9378	"succneqq;": "\u2AB6",
9379	"succnsim;": "\u22E9",
9380	"succsim;": "\u227F",
9381	"SuchThat;": "\u220B",
9382	"sum;": "\u2211",
9383	"Sum;": "\u2211",
9384	"sung;": "\u266A",
9385	"sup1;": "\u00B9",
9386	"sup1": "\u00B9",
9387	"sup2;": "\u00B2",
9388	"sup2": "\u00B2",
9389	"sup3;": "\u00B3",
9390	"sup3": "\u00B3",
9391	"sup;": "\u2283",
9392	"Sup;": "\u22D1",
9393	"supdot;": "\u2ABE",
9394	"supdsub;": "\u2AD8",
9395	"supE;": "\u2AC6",
9396	"supe;": "\u2287",
9397	"supedot;": "\u2AC4",
9398	"Superset;": "\u2283",
9399	"SupersetEqual;": "\u2287",
9400	"suphsol;": "\u27C9",
9401	"suphsub;": "\u2AD7",
9402	"suplarr;": "\u297B",
9403	"supmult;": "\u2AC2",
9404	"supnE;": "\u2ACC",
9405	"supne;": "\u228B",
9406	"supplus;": "\u2AC0",
9407	"supset;": "\u2283",
9408	"Supset;": "\u22D1",
9409	"supseteq;": "\u2287",
9410	"supseteqq;": "\u2AC6",
9411	"supsetneq;": "\u228B",
9412	"supsetneqq;": "\u2ACC",
9413	"supsim;": "\u2AC8",
9414	"supsub;": "\u2AD4",
9415	"supsup;": "\u2AD6",
9416	"swarhk;": "\u2926",
9417	"swarr;": "\u2199",
9418	"swArr;": "\u21D9",
9419	"swarrow;": "\u2199",
9420	"swnwar;": "\u292A",
9421	"szlig;": "\u00DF",
9422	"szlig": "\u00DF",
9423	"Tab;": "\u0009",
9424	"target;": "\u2316",
9425	"Tau;": "\u03A4",
9426	"tau;": "\u03C4",
9427	"tbrk;": "\u23B4",
9428	"Tcaron;": "\u0164",
9429	"tcaron;": "\u0165",
9430	"Tcedil;": "\u0162",
9431	"tcedil;": "\u0163",
9432	"Tcy;": "\u0422",
9433	"tcy;": "\u0442",
9434	"tdot;": "\u20DB",
9435	"telrec;": "\u2315",
9436	"Tfr;": "\uD835\uDD17",
9437	"tfr;": "\uD835\uDD31",
9438	"there4;": "\u2234",
9439	"therefore;": "\u2234",
9440	"Therefore;": "\u2234",
9441	"Theta;": "\u0398",
9442	"theta;": "\u03B8",
9443	"thetasym;": "\u03D1",
9444	"thetav;": "\u03D1",
9445	"thickapprox;": "\u2248",
9446	"thicksim;": "\u223C",
9447	"ThickSpace;": "\u205F\u200A",
9448	"ThinSpace;": "\u2009",
9449	"thinsp;": "\u2009",
9450	"thkap;": "\u2248",
9451	"thksim;": "\u223C",
9452	"THORN;": "\u00DE",
9453	"THORN": "\u00DE",
9454	"thorn;": "\u00FE",
9455	"thorn": "\u00FE",
9456	"tilde;": "\u02DC",
9457	"Tilde;": "\u223C",
9458	"TildeEqual;": "\u2243",
9459	"TildeFullEqual;": "\u2245",
9460	"TildeTilde;": "\u2248",
9461	"timesbar;": "\u2A31",
9462	"timesb;": "\u22A0",
9463	"times;": "\u00D7",
9464	"times": "\u00D7",
9465	"timesd;": "\u2A30",
9466	"tint;": "\u222D",
9467	"toea;": "\u2928",
9468	"topbot;": "\u2336",
9469	"topcir;": "\u2AF1",
9470	"top;": "\u22A4",
9471	"Topf;": "\uD835\uDD4B",
9472	"topf;": "\uD835\uDD65",
9473	"topfork;": "\u2ADA",
9474	"tosa;": "\u2929",
9475	"tprime;": "\u2034",
9476	"trade;": "\u2122",
9477	"TRADE;": "\u2122",
9478	"triangle;": "\u25B5",
9479	"triangledown;": "\u25BF",
9480	"triangleleft;": "\u25C3",
9481	"trianglelefteq;": "\u22B4",
9482	"triangleq;": "\u225C",
9483	"triangleright;": "\u25B9",
9484	"trianglerighteq;": "\u22B5",
9485	"tridot;": "\u25EC",
9486	"trie;": "\u225C",
9487	"triminus;": "\u2A3A",
9488	"TripleDot;": "\u20DB",
9489	"triplus;": "\u2A39",
9490	"trisb;": "\u29CD",
9491	"tritime;": "\u2A3B",
9492	"trpezium;": "\u23E2",
9493	"Tscr;": "\uD835\uDCAF",
9494	"tscr;": "\uD835\uDCC9",
9495	"TScy;": "\u0426",
9496	"tscy;": "\u0446",
9497	"TSHcy;": "\u040B",
9498	"tshcy;": "\u045B",
9499	"Tstrok;": "\u0166",
9500	"tstrok;": "\u0167",
9501	"twixt;": "\u226C",
9502	"twoheadleftarrow;": "\u219E",
9503	"twoheadrightarrow;": "\u21A0",
9504	"Uacute;": "\u00DA",

9505	"Uacute": "\u00DA",
9506	"uacute;": "\u00FA",
9507	"uacute": "\u00FA",
9508	"uarr;": "\u2191",
9509	"Uarr;": "\u219F",
9510	"uArr;": "\u21D1",
9511	"Uarrocir;": "\u2949",
9512	"Ubrcy;": "\u040E",
9513	"ubrcy;": "\u045E",
9514	"Ubreve;": "\u016C",
9515	"ubreve;": "\u016D",
9516	"Ucirc;": "\u00DB",
9517	"Ucirc": "\u00DB",
9518	"ucirc;": "\u00FB",
9519	"ucirc": "\u00FB",
9520	"Ucy;": "\u0423",
9521	"ucy;": "\u0443",
9522	"udarr;": "\u21C5",
9523	"Udblac;": "\u0170",
9524	"udblac;": "\u0171",
9525	"udhar;": "\u296E",
9526	"ufisht;": "\u297E",
9527	"Ufr;": "\uD835\uDD18",
9528	"ufr;": "\uD835\uDD32",
9529	"Ugrave;": "\u00D9",
9530	"Ugrave": "\u00D9",
9531	"ugrave;": "\u00F9",
9532	"ugrave": "\u00F9",
9533	"uHar;": "\u2963",
9534	"uharl;": "\u21BF",
9535	"uharr;": "\u21BE",
9536	"uhblk;": "\u2580",
9537	"ulcorn;": "\u231C",
9538	"ulcorner;": "\u231C",
9539	"ulcrop;": "\u230F",
9540	"ultri;": "\u25F8",
9541	"Umacr;": "\u016A",
9542	"umacr;": "\u016B",
9543	"uml;": "\u00A8",
9544	"uml": "\u00A8",
9545	"UnderBar;": "\u005F",
9546	"UnderBrace;": "\u23DF",
9547	"UnderBracket;": "\u23B5",
9548	"UnderParenthesis;": "\u23DD",
9549	"Union;": "\u22C3",
9550	"UnionPlus;": "\u228E",
9551	"Uogon;": "\u0172",
9552	"uogon;": "\u0173",
9553	"Uopf;": "\uD835\uDD4C",
9554	"uopf;": "\uD835\uDD66",
9555	"UpArrowBar;": "\u2912",
9556	"uparrow;": "\u2191",
9557	"UpArrow;": "\u2191",
9558	"Uparrow;": "\u21D1",
9559	"UpArrowDownArrow;": "\u21C5",
9560	"updownarrow;": "\u2195",
9561	"UpDownArrow;": "\u2195",
9562	"Updownarrow;": "\u21D5",
9563	"UpEquilibrium;": "\u296E",
9564	"upharpoonleft;": "\u21BF",
9565	"upharpoonright;": "\u21BE",
9566	"uplus;": "\u228E",
9567	"UpperLeftArrow;": "\u2196",
9568	"UpperRightArrow;": "\u2197",
9569	"upsi;": "\u03C5",
9570	"Upsi;": "\u03D2",
9571	"upsih;": "\u03D2",
9572	"Upsilon;": "\u03A5",
9573	"upsilon;": "\u03C5",
9574	"UpTeeArrow;": "\u21A5",
9575	"UpTee;": "\u22A5",
9576	"upuparrows;": "\u21C8",
9577	"urcorn;": "\u231D",
9578	"urcorner;": "\u231D",
9579	"urcrop;": "\u230E",
9580	"Uring;": "\u016E",
9581	"uring;": "\u016F",
9582	"urtri;": "\u25F9",
9583	"Uscr;": "\uD835\uDCB0",
9584	"uscr;": "\uD835\uDCCA",
9585	"utdot;": "\u22F0",
9586	"Utilde;": "\u0168",
9587	"utilde;": "\u0169",
9588	"utri;": "\u25B5",
9589	"utrif;": "\u25B4",
9590	"uuarr;": "\u21C8",
9591	"Uuml;": "\u00DC",
9592	"Uuml": "\u00DC",
9593	"uuml;": "\u00FC",
9594	"uuml": "\u00FC",
9595	"uwangle;": "\u29A7",
9596	"vangrt;": "\u299C",
9597	"varepsilon;": "\u03F5",
9598	"varkappa;": "\u03F0",
9599	"varnothing;": "\u2205",
9600	"varphi;": "\u03D5",
9601	"varpi;": "\u03D6",
9602	"varpropto;": "\u221D",
9603	"varr;": "\u2195",
9604	"vArr;": "\u21D5",
9605	"varrho;": "\u03F1",
9606	"varsigma;": "\u03C2",
9607	"varsubsetneq;": "\u228A\uFE00",
9608	"varsubsetneqq;": "\u2ACB\uFE00",
9609	"varsupsetneq;": "\u228B\uFE00",
9610	"varsupsetneqq;": "\u2ACC\uFE00",
9611	"vartheta;": "\u03D1",
9612	"vartriangleleft;": "\u22B2",
9613	"vartriangleright;": "\u22B3",
9614	"vBar;": "\u2AE8",
9615	"Vbar;": "\u2AEB",
9616	"vBarv;": "\u2AE9",
9617	"Vcy;": "\u0412",
9618	"vcy;": "\u0432",
9619	"vdash;": "\u22A2",
9620	"vDash;": "\u22A8",
9621	"Vdash;": "\u22A9",
9622	"VDash;": "\u22AB",
9623	"Vdashl;": "\u2AE6",
9624	"veebar;": "\u22BB",
9625	"vee;": "\u2228",
9626	"Vee;": "\u22C1",
9627	"veeeq;": "\u225A",
9628	"vellip;": "\u22EE",
9629	"verbar;": "\u007C",
9630	"Verbar;": "\u2016",
9631	"vert;": "\u007C",
9632	"Vert;": "\u2016",
9633	"VerticalBar;": "\u2223",
9634	"VerticalLine;": "\u007C",
9635	"VerticalSeparator;": "\u2758",
9636	"VerticalTilde;": "\u2240",
9637	"VeryThinSpace;": "\u200A",
9638	"Vfr;": "\uD835\uDD19",
9639	"vfr;": "\uD835\uDD33",
9640	"vltri;": "\u22B2",
9641	"vnsub;": "\u2282\u20D2",
9642	"vnsup;": "\u2283\u20D2",
9643	"Vopf;": "\uD835\uDD4D",
9644	"vopf;": "\uD835\uDD67",
9645	"vprop;": "\u221D",
9646	"vrtri;": "\u22B3",
9647	"Vscr;": "\uD835\uDCB1",
9648	"vscr;": "\uD835\uDCCB",
9649	"vsubnE;": "\u2ACB\uFE00",
9650	"vsubne;": "\u228A\uFE00",
9651	"vsupnE;": "\u2ACC\uFE00",
9652	"vsupne;": "\u228B\uFE00",
9653	"Vvdash;": "\u22AA",
9654	"vzigzag;": "\u299A",
9655	"Wcirc;": "\u0174",
9656	"wcirc;": "\u0175",
9657	"wedbar;": "\u2A5F",
9658	"wedge;": "\u2227",
9659	"Wedge;": "\u22C0",
9660	"wedgeq;": "\u2259",
9661	"weierp;": "\u2118",
9662	"Wfr;": "\uD835\uDD1A",
9663	"wfr;": "\uD835\uDD34",
9664	"Wopf;": "\uD835\uDD4E",
9665	"wopf;": "\uD835\uDD68",
9666	"wp;": "\u2118",
9667	"wr;": "\u2240",
9668	"wreath;": "\u2240",
9669	"Wscr;": "\uD835\uDCB2",
9670	"wscr;": "\uD835\uDCCC",
9671	"xcap;": "\u22C2",
9672	"xcirc;": "\u25EF",
9673	"xcup;": "\u22C3",
9674	"xdtri;": "\u25BD",
9675	"Xfr;": "\uD835\uDD1B",
9676	"xfr;": "\uD835\uDD35",
9677	"xharr;": "\u27F7",
9678	"xhArr;": "\u27FA",
9679	"Xi;": "\u039E",
9680	"xi;": "\u03BE",
9681	"xlarr;": "\u27F5",
9682	"xlArr;": "\u27F8",

9683	"xmap;": "\u27FC",
9684	"xnis;": "\u22FB",
9685	"xodot;": "\u2A00",
9686	"Xopf;": "\uD835\uDD4F",
9687	"xopf;": "\uD835\uDD69",
9688	"xoplus;": "\u2A01",
9689	"xotime;": "\u2A02",
9690	"xrarr;": "\u27F6",
9691	"xrArr;": "\u27F9",
9692	"Xscr;": "\uD835\uDCB3",
9693	"xscr;": "\uD835\uDCCD",
9694	"xsqcup;": "\u2A06",
9695	"xuplus;": "\u2A04",
9696	"xutri;": "\u25B3",
9697	"xvee;": "\u22C1",
9698	"xwedge;": "\u22C0",
9699	"Yacute;": "\u00DD",
9700	"Yacute": "\u00DD",
9701	"yacute;": "\u00FD",
9702	"yacute": "\u00FD",
9703	"YAcy;": "\u042F",
9704	"yacy;": "\u044F",
9705	"Ycirc;": "\u0176",
9706	"ycirc;": "\u0177",
9707	"Ycy;": "\u042B",
9708	"ycy;": "\u044B",
9709	"yen;": "\u00A5",
9710	"yen": "\u00A5",
9711	"Yfr;": "\uD835\uDD1C",
9712	"yfr;": "\uD835\uDD36",
9713	"YIcy;": "\u0407",
9714	"yicy;": "\u0457",
9715	"Yopf;": "\uD835\uDD50",
9716	"yopf;": "\uD835\uDD6A",
9717	"Yscr;": "\uD835\uDCB4",
9718	"yscr;": "\uD835\uDCCE",
9719	"YUcy;": "\u042E",
9720	"yucy;": "\u044E",
9721	"yuml;": "\u00FF",
9722	"yuml": "\u00FF",
9723	"Yuml;": "\u0178",
9724	"Zacute;": "\u0179",
9725	"zacute;": "\u017A",
9726	"Zcaron;": "\u017D",
9727	"zcaron;": "\u017E",
9728	"Zcy;": "\u0417",
9729	"zcy;": "\u0437",
9730	"Zdot;": "\u017B",
9731	"zdot;": "\u017C",
9732	"zeetrf;": "\u2128",
9733	"ZeroWidthSpace;": "\u200B",
9734	"Zeta;": "\u0396",
9735	"zeta;": "\u03B6",
9736	"zfr;": "\uD835\uDD37",
9737	"Zfr;": "\u2128",
9738	"ZHcy;": "\u0416",
9739	"zhcy;": "\u0436",
9740	"zigrarr;": "\u21DD",
9741	"zopf;": "\uD835\uDD6B",
9742	"Zopf;": "\u2124",
9743	"Zscr;": "\uD835\uDCB5",
9744	"zscr;": "\uD835\uDCCF",
9745	"zwj;": "\u200D",
9746	"zwnj;": "\u200C"
9747};
9748
9749},
9750{}],
975113:[function(_dereq_,module,exports){
9752var util = _dereq_('util/');
9753
9754var pSlice = Array.prototype.slice;
9755var hasOwn = Object.prototype.hasOwnProperty;
9756
9757var assert = module.exports = ok;
9758
9759assert.AssertionError = function AssertionError(options) {
9760  this.name = 'AssertionError';
9761  this.actual = options.actual;
9762  this.expected = options.expected;
9763  this.operator = options.operator;
9764  if (options.message) {
9765    this.message = options.message;
9766    this.generatedMessage = false;
9767  } else {
9768    this.message = getMessage(this);
9769    this.generatedMessage = true;
9770  }
9771  var stackStartFunction = options.stackStartFunction || fail;
9772
9773  if (Error.captureStackTrace) {
9774    Error.captureStackTrace(this, stackStartFunction);
9775  }
9776  else {
9777    var err = new Error();
9778    if (err.stack) {
9779      var out = err.stack;
9780      var fn_name = stackStartFunction.name;
9781      var idx = out.indexOf('\n' + fn_name);
9782      if (idx >= 0) {
9783        var next_line = out.indexOf('\n', idx + 1);
9784        out = out.substring(next_line + 1);
9785      }
9786
9787      this.stack = out;
9788    }
9789  }
9790};
9791util.inherits(assert.AssertionError, Error);
9792
9793function replacer(key, value) {
9794  if (util.isUndefined(value)) {
9795    return '' + value;
9796  }
9797  if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
9798    return value.toString();
9799  }
9800  if (util.isFunction(value) || util.isRegExp(value)) {
9801    return value.toString();
9802  }
9803  return value;
9804}
9805
9806function truncate(s, n) {
9807  if (util.isString(s)) {
9808    return s.length < n ? s : s.slice(0, n);
9809  } else {
9810    return s;
9811  }
9812}
9813
9814function getMessage(self) {
9815  return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
9816         self.operator + ' ' +
9817         truncate(JSON.stringify(self.expected, replacer), 128);
9818}
9819
9820function fail(actual, expected, message, operator, stackStartFunction) {
9821  throw new assert.AssertionError({
9822    message: message,
9823    actual: actual,
9824    expected: expected,
9825    operator: operator,
9826    stackStartFunction: stackStartFunction
9827  });
9828}
9829assert.fail = fail;
9830
9831function ok(value, message) {
9832  if (!value) fail(value, true, message, '==', assert.ok);
9833}
9834assert.ok = ok;
9835
9836assert.equal = function equal(actual, expected, message) {
9837  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
9838};
9839
9840assert.notEqual = function notEqual(actual, expected, message) {
9841  if (actual == expected) {
9842    fail(actual, expected, message, '!=', assert.notEqual);
9843  }
9844};
9845
9846assert.deepEqual = function deepEqual(actual, expected, message) {
9847  if (!_deepEqual(actual, expected)) {
9848    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
9849  }
9850};
9851
9852function _deepEqual(actual, expected) {
9853  if (actual === expected) {
9854    return true;
9855
9856  }

9856 else if (util.isBuffer(actual) && util.isBuffer(expected)) {
9857    if (actual.length != expected.length) return false;
9858
9859    for (var i = 0; i < actual.length; i++) {
9860      if (actual[i] !== expected[i]) return false;
9861    }
9862
9863    return true;
9864  } else if (util.isDate(actual) && util.isDate(expected)) {
9865    return actual.getTime() === expected.getTime();
9866  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
9867    return actual.source === expected.source &&
9868           actual.global === expected.global &&
9869           actual.multiline === expected.multiline &&
9870           actual.lastIndex === expected.lastIndex &&
9871           actual.ignoreCase === expected.ignoreCase;
9872  } else if (!util.isObject(actual) && !util.isObject(expected)) {
9873    return actual == expected;
9874  } else {
9875    return objEquiv(actual, expected);
9876  }
9877}
9878
9879function isArguments(object) {
9880  return Object.prototype.toString.call(object) == '[object Arguments]';
9881}
9882
9883function objEquiv(a, b) {
9884  if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
9885    return false;
9886  if (a.prototype !== b.prototype) return false;
9887  if (isArguments(a)) {
9888    if (!isArguments(b)) {
9889      return false;
9890    }
9891    a = pSlice.call(a);
9892    b = pSlice.call(b);
9893    return _deepEqual(a, b);
9894  }
9895  try {
9896    var ka = objectKeys(a),
9897        kb = objectKeys(b),
9898        key, i;
9899  } catch (e) {//happens when one is a string literal and the other isn't
9900    return false;
9901  }
9902  if (ka.length != kb.length)
9903    return false;
9904  ka.sort();
9905  kb.sort();
9906  for (i = ka.length - 1; i >= 0; i--) {
9907    if (ka[i] != kb[i])
9908      return false;
9909  }
9910  for (i = ka.length - 1; i >= 0; i--) {
9911    key = ka[i];
9912    if (!_deepEqual(a[key], b[key])) return false;
9913  }
9914  return true;
9915}
9916
9917assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
9918  if (_deepEqual(actual, expected)) {
9919    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
9920  }
9921};
9922
9923assert.strictEqual = function strictEqual(actual, expected, message) {
9924  if (actual !== expected) {
9925    fail(actual, expected, message, '===', assert.strictEqual);
9926  }
9927};
9928
9929assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
9930  if (actual === expected) {
9931    fail(actual, expected, message, '!==', assert.notStrictEqual);
9932  }
9933};
9934
9935function expectedException(actual, expected) {
9936  if (!actual || !expected) {
9937    return false;
9938  }
9939
9940  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
9941    return expected.test(actual);
9942  } else if (actual instanceof expected) {
9943    return true;
9944  } else if (expected.call({}, actual) === true) {
9945    return true;
9946  }
9947
9948  return false;
9949}
9950
9951function _throws(shouldThrow, block, expected, message) {
9952  var actual;
9953
9954  if (util.isString(expected)) {
9955    message = expected;
9956    expected = null;
9957  }
9958
9959  try {
9960    block();
9961  } catch (e) {
9962    actual = e;
9963  }
9964
9965  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
9966            (message ? ' ' + message : '.');
9967
9968  if (shouldThrow && !actual) {
9969    fail(actual, expected, 'Missing expected exception' + message);
9970  }
9971
9972  if (!shouldThrow && expectedException(actual, expected)) {
9973    fail(actual, expected, 'Got unwanted exception' + message);
9974  }
9975
9976  if ((shouldThrow && actual && expected &&
9977      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
9978    throw actual;
9979  }
9980}
9981
9982assert.throws = function(block, /*optional*/error, /*optional*/message) {
9983  _throws.apply(this, [true].concat(pSlice.call(arguments)));
9984};
9985assert.doesNotThrow = function(block, /*optional*/message) {
9986  _throws.apply(this, [false].concat(pSlice.call(arguments)));
9987};
9988
9989assert.ifError = function(err) { if (err) {throw err;}};
9990
9991var objectKeys = Object.keys || function (obj) {
9992  var keys = [];
9993  for (var key in obj) {
9994    if (hasOwn.call(obj, key)) keys.push(key);
9995  }
9996  return keys;
9997};
9998
9999},
10000{"util/":15}],
1000114:[function(_dereq_,module,exports){
10002module.exports = function isBuffer(arg) {
10003  return arg && typeof arg === 'object'
10004    && typeof arg.copy === 'function'
10005    && typeof arg.fill === 'function'
10006    && typeof arg.readUInt8 === 'function';
10007}
10008},
10009{}],
1001015:[function(_dereq_,module,exports){
10011(function (process,global){
10012
10013var formatRegExp = /%[sdj%]/g;
10014exports.format = function(f) {
10015  if (!isString(f)) {
10016    var objects = [];
10017    for (var i = 0; i < arguments.length; i++) {
10018      objects.push(inspect(arguments[i]));
10019    }
10020    return objects.join(' ');
10021  }
10022
10023  var i = 1;
10024  var args = arguments;
10025  var len = args.length;
10026  var str = String(f).replace(formatRegExp, function(x) {
10027    if (x === '%%') return '%';
10028    if (i >= len) return x;
10029    switch (x) {
10030      case '%s': return String(args[i++]);
10031      case '%d': return Number(args[i++]);
10032      case '%j':
10033        try {
10034          return JSON.stringify(args[i++]);
10035        } catch (_) {
10036          return '[Circular]';
10037        }
10038      default:
10039        return x;
10040    }
10041  });
10042  for (var x = args[i]; i < len; x = args[++i]) {
10043    if (isNull(x) || !isObject(x)) {
10044      str += ' ' + x;
10045    } else {
10046      str += ' ' + inspect(x);
10047    }
10048  }
10049  return str;
10050};
10051exports.deprecate = function(fn, msg) {
10052  if (isUndefined(global.process)) {
10053    return function() {
10054      return exports.deprecate(fn, msg).apply(this, arguments);
10055    };
10056  }
10057
10058  if (process.noDeprecation === true) {
10059    return fn;
10060  }
10061
10062  var warned = false;

vendor: 10,616 bytes, lines 10063-10493

10063  function deprecated() {
10064    if (!warned) {
10065      if (process.throwDeprecation) {
10066        throw new Error(msg);
10067      } else if (process.traceDeprecation) {
10068        console.trace(msg);
10069      } else {
10070        console.error(msg);
10071      }
10072      warned = true;
10073    }
10074    return fn.apply(this, arguments);
10075  }
10076
10077  return deprecated;
10078};
10079
10080
10081var debugs = {};
10082var debugEnviron;
10083exports.debuglog = function(set) {
10084  if (isUndefined(debugEnviron))
10085    debugEnviron = process.env.NODE_DEBUG || '';
10086  set = set.toUpperCase();
10087  if (!debugs[set]) {
10088    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
10089      var pid = process.pid;
10090      debugs[set] = function() {
10091        var msg = exports.format.apply(exports, arguments);
10092        console.error('%s %d: %s', set, pid, msg);
10093      };
10094    } else {
10095      debugs[set] = function() {};
10096    }
10097  }
10098  return debugs[set];
10099};
10100function inspect(obj, opts) {
10101  var ctx = {
10102    seen: [],
10103    stylize: stylizeNoColor
10104  };
10105  if (arguments.length >= 3) ctx.depth = arguments[2];
10106  if (arguments.length >= 4) ctx.colors = arguments[3];
10107  if (isBoolean(opts)) {
10108    ctx.showHidden = opts;
10109  } else if (opts) {
10110    exports._extend(ctx, opts);
10111  }
10112  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
10113  if (isUndefined(ctx.depth)) ctx.depth = 2;
10114  if (isUndefined(ctx.colors)) ctx.colors = false;
10115  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
10116  if (ctx.colors) ctx.stylize = stylizeWithColor;
10117  return formatValue(ctx, obj, ctx.depth);
10118}
10119exports.inspect = inspect;
10120inspect.colors = {
10121  'bold' : [1, 22],
10122  'italic' : [3, 23],
10123  'underline' : [4, 24],
10124  'inverse' : [7, 27],
10125  'white' : [37, 39],
10126  'grey' : [90, 39],
10127  'black' : [30, 39],
10128  'blue' : [34, 39],
10129  'cyan' : [36, 39],
10130  'green' : [32, 39],
10131  'magenta' : [35, 39],
10132  'red' : [31, 39],
10133  'yellow' : [33, 39]
10134};
10135inspect.styles = {
10136  'special': 'cyan',
10137  'number': 'yellow',
10138  'boolean': 'yellow',
10139  'undefined': 'grey',
10140  'null': 'bold',
10141  'string': 'green',
10142  'date': 'magenta',
10143  'regexp': 'red'
10144};
10145
10146
10147function stylizeWithColor(str, styleType) {
10148  var style = inspect.styles[styleType];
10149
10150  if (style) {
10151    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
10152           '\u001b[' + inspect.colors[style][1] + 'm';
10153  } else {
10154    return str;
10155  }
10156}
10157
10158
10159function stylizeNoColor(str, styleType) {
10160  return str;
10161}
10162
10163
10164function arrayToHash(array) {
10165  var hash = {};
10166
10167  array.forEach(function(val, idx) {
10168    hash[val] = true;
10169  });
10170
10171  return hash;
10172}
10173
10174
10175function formatValue(ctx, value, recurseTimes) {
10176  if (ctx.customInspect &&
10177      value &&
10178      isFunction(value.inspect) &&
10179      value.inspect !== exports.inspect &&
10180      !(value.constructor && value.constructor.prototype === value)) {
10181    var ret = value.inspect(recurseTimes, ctx);
10182    if (!isString(ret)) {
10183      ret = formatValue(ctx, ret, recurseTimes);
10184    }
10185    return ret;
10186  }
10187  var primitive = formatPrimitive(ctx, value);
10188  if (primitive) {
10189    return primitive;
10190  }
10191  var keys = Object.keys(value);
10192  var visibleKeys = arrayToHash(keys);
10193
10194  if (ctx.showHidden) {
10195    keys = Object.getOwnPropertyNames(value);
10196  }
10197  if (isError(value)
10198      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
10199    return formatError(value);
10200  }
10201  if (keys.length === 0) {
10202    if (isFunction(value)) {
10203      var name = value.name ? ': ' + value.name : '';
10204      return ctx.stylize('[Function' + name + ']', 'special');
10205    }
10206    if (isRegExp(value)) {
10207      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
10208    }
10209    if (isDate(value)) {
10210      return ctx.stylize(Date.prototype.toString.call(value), 'date');
10211    }
10212    if (isError(value)) {
10213      return formatError(value);
10214    }
10215  }
10216
10217  var base = '', array = false, braces = ['{', '}'];
10218  if (isArray(value)) {
10219    array = true;
10220    braces = ['[', ']'];
10221  }
10222  if (isFunction(value)) {
10223    var n = value.name ? ': ' + value.name : '';
10224    base = ' [Function' + n + ']';
10225  }
10226  if (isRegExp(value)) {
10227    base = ' ' + RegExp.prototype.toString.call(value);
10228  }
10229  if (isDate(value)) {
10230    base = ' ' + Date.prototype.toUTCString.call(value);
10231  }
10232  if (isError(value)) {
10233    base = ' ' + formatError(value);
10234  }
10235
10236  if (keys.length === 0 && (!array || value.length == 0)) {
10237    return braces[0] + base + braces[1];
10238  }
10239
10240  if (recurseTimes < 0) {
10241    if (isRegExp(value)) {
10242      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
10243    } else {
10244      return ctx.stylize('[Object]', 'special');
10245    }
10246  }
10247
10248  ctx.seen.push(value);
10249
10250  var output;
10251  if (array) {
10252    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
10253  } else {
10254    output = keys.map(function(key) {
10255      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
10256    });
10257  }
10258
10259  ctx.seen.pop();
10260
10261  return reduceToSingleString(output, base, braces);
10262}
10263
10264
10265function formatPrimitive(ctx, value) {
10266  if (isUndefined(value))
10267    return ctx.stylize('undefined', 'undefined');
10268  if (isString(value)) {
10269    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
10270                                             .replace(/'/g, "\\'")
10271                                             .replace(/\\"/g, '"') + '\'';
10272    return ctx.stylize(simple, 'string');
10273  }
10274  if (isNumber(value))
10275    return ctx.stylize('' + value, 'number');
10276  if (isBoolean(value))
10277    return ctx.stylize('' + value, 'boolean');
10278  if (isNull(value))
10279    return ctx.stylize('null', 'null');
10280}
10281
10282
10283function formatError(value) {
10284  return '[' + Error.prototype.toString.call(value) + ']';
10285}
10286
10287
10288function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
10289  var output = [];
10290  for (var i = 0, l = value.length; i < l; ++i) {
10291    if (hasOwnProperty(value, String(i))) {
10292      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
10293          String(i), true));
10294    } else {
10295      output.push('');
10296    }
10297  }
10298  keys.forEach(function(key) {
10299    if (!key.match(/^\d+$/)) {
10300      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
10301          key, true));
10302    }
10303  });
10304  return output;
10305}
10306
10307
10308function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
10309  var name, str, desc;
10310  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
10311  if (desc.get) {
10312    if (desc.set) {
10313      str = ctx.stylize('[Getter/Setter]', 'special');
10314    } else {
10315      str = ctx.stylize('[Getter]', 'special');
10316    }
10317  } else {
10318    if (desc.set) {
10319      str = ctx.stylize('[Setter]', 'special');
10320    }
10321  }
10322  if (!hasOwnProperty(visibleKeys, key)) {
10323    name = '[' + key + ']';
10324  }
10325  if (!str) {
10326    if (ctx.seen.indexOf(desc.value) < 0) {
10327      if (isNull(recurseTimes)) {
10328        str = formatValue(ctx, desc.value, null);
10329      } else {
10330        str = formatValue(ctx, desc.value, recurseTimes - 1);
10331      }
10332      if (str.indexOf('\n') > -1) {
10333        if (array) {
10334          str = str.split('\n').map(function(line) {
10335            return '  ' + line;
10336          }).join('\n').substr(2);
10337        } else {
10338          str = '\n' + str.split('\n').map(function(line) {
10339            return '   ' + line;
10340          }).join('\n');
10341        }
10342      }
10343    } else {
10344      str = ctx.stylize('[Circular]', 'special');
10345    }
10346  }
10347  if (isUndefined(name)) {
10348    if (array && key.match(/^\d+$/)) {
10349      return str;
10350    }
10351    name = JSON.stringify('' + key);
10352    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
10353      name = name.substr(1, name.length - 2);
10354      name = ctx.stylize(name, 'name');
10355    } else {
10356      name = name.replace(/'/g, "\\'")
10357                 .replace(/\\"/g, '"')
10358                 .replace(/(^"|"$)/g, "'");
10359      name = ctx.stylize(name, 'string');
10360    }
10361  }
10362
10363  return name + ': ' + str;
10364}
10365
10366
10367function reduceToSingleString(output, base, braces) {
10368  var numLinesEst = 0;
10369  var length = output.reduce(function(prev, cur) {
10370    numLinesEst++;
10371    if (cur.indexOf('\n') >= 0) numLinesEst++;
10372    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
10373  }, 0);
10374
10375  if (length > 60) {
10376    return braces[0] +
10377           (base === '' ? '' : base + '\n ') +
10378           ' ' +
10379           output.join(',\n  ') +
10380           ' ' +
10381           braces[1];
10382  }
10383
10384  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
10385}
10386function isArray(ar) {
10387  return Array.isArray(ar);
10388}
10389exports.isArray = isArray;
10390
10391function isBoolean(arg) {
10392  return typeof arg === 'boolean';
10393}
10394exports.isBoolean = isBoolean;
10395
10396function isNull(arg) {
10397  return arg === null;
10398}
10399exports.isNull = isNull;
10400
10401function isNullOrUndefined(arg) {
10402  return arg == null;
10403}
10404exports.isNullOrUndefined = isNullOrUndefined;
10405
10406function isNumber(arg) {
10407  return typeof arg === 'number';
10408}
10409exports.isNumber = isNumber;
10410
10411function isString(arg) {
10412  return typeof arg === 'string';
10413}
10414exports.isString = isString;
10415
10416function isSymbol(arg) {
10417  return typeof arg === 'symbol';
10418}
10419exports.isSymbol = isSymbol;
10420
10421function isUndefined(arg) {
10422  return arg === void 0;
10423}
10424exports.isUndefined = isUndefined;
10425
10426function isRegExp(re) {
10427  return isObject(re) && objectToString(re) === '[object RegExp]';
10428}
10429exports.isRegExp = isRegExp;
10430
10431function isObject(arg) {
10432  return typeof arg === 'object' && arg !== null;
10433}
10434exports.isObject = isObject;
10435
10436function isDate(d) {
10437  return isObject(d) && objectToString(d) === '[object Date]';
10438}
10439exports.isDate = isDate;
10440
10441function isError(e) {
10442  return isObject(e) &&
10443      (objectToString(e) === '[object Error]' || e instanceof Error);
10444}
10445exports.isError = isError;
10446
10447function isFunction(arg) {
10448  return typeof arg === 'function';
10449}
10450exports.isFunction = isFunction;
10451
10452function isPrimitive(arg) {
10453  return arg === null ||
10454         typeof arg === 'boolean' ||
10455         typeof arg === 'number' ||
10456         typeof arg === 'string' ||
10457         typeof arg === 'symbol' ||  // ES6 symbol
10458         typeof arg === 'undefined';
10459}
10460exports.isPrimitive = isPrimitive;
10461
10462exports.isBuffer = _dereq_('./support/isBuffer');
10463
10464function objectToString(o) {
10465  return Object.prototype.toString.call(o);
10466}
10467
10468
10469function pad(n) {
10470  return n < 10 ? '0' + n.toString(10) : n.toString(10);
10471}
10472
10473
10474var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
10475              'Oct', 'Nov', 'Dec'];
10476function timestamp() {
10477  var d = new Date();
10478  var time = [pad(d.getHours()),
10479              pad(d.getMinutes()),
10480              pad(d.getSeconds())].join(':');
10481  return [d.getDate(), months[d.getMonth()], time].join(' ');
10482}
10483exports.log = function() {
10484  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
10485};
10486exports.inherits = _dereq_('inherits');
10487
10488exports._extend = function(origin, add) {
10489  if (!add || !isObject(add)) return origin;
10490
10491  var keys = Object.keys(add);
10492  var i = keys.length;
10493  while (i--) {

10494    origin[keys[i]] = add[keys[i]];
10495  }
10496  return origin;
10497};
10498
10499function hasOwnProperty(obj, prop) {
10500  return Object.prototype.hasOwnProperty.call(obj, prop);
10501}
10502
10503}).call(this,_dereq_("/usr/local/lib/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
10504},
10505{"./support/isBuffer":14,"/usr/local/lib/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":18,"inherits":17}],
1050616:[function(_dereq_,module,exports){
10507
10508function EventEmitter() {
10509  this._events = this._events || {};
10510  this._maxListeners = this._maxListeners || undefined;
10511}
10512module.exports = EventEmitter;
10513EventEmitter.EventEmitter = EventEmitter;
10514
10515EventEmitter.prototype._events = undefined;
10516EventEmitter.prototype._maxListeners = undefined;
10517EventEmitter.defaultMaxListeners = 10;
10518EventEmitter.prototype.setMaxListeners = function(n) {
10519  if (!isNumber(n) || n < 0 || isNaN(n))
10520    throw TypeError('n must be a positive number');
10521  this._maxListeners = n;
10522  return this;
10523};
10524
10525EventEmitter.prototype.emit = function(type) {
10526  var er, handler, len, args, i, listeners;
10527
10528  if (!this._events)
10529    this._events = {};
10530  if (type === 'error') {
10531    if (!this._events.error ||
10532        (isObject(this._events.error) && !this._events.error.length)) {
10533      er = arguments[1];
10534      if (er instanceof Error) {
10535        throw er; // Unhandled 'error' event
10536      } else {
10537        throw TypeError('Uncaught, unspecified "error" event.');
10538      }
10539      return false;
10540    }
10541  }
10542
10543  handler = this._events[type];
10544
10545  if (isUndefined(handler))
10546    return false;
10547
10548  if (isFunction(handler)) {
10549    switch (arguments.length) {
10550      case 1:
10551        handler.call(this);
10552        break;
10553      case 2:
10554        handler.call(this, arguments[1]);
10555        break;
10556      case 3:
10557        handler.call(this, arguments[1], arguments[2]);
10558        break;
10559      default:
10560        len = arguments.length;
10561        args = new Array(len - 1);
10562        for (i = 1; i < len; i++)
10563          args[i - 1] = arguments[i];
10564        handler.apply(this, args);
10565    }
10566  } else if (isObject(handler)) {
10567    len = arguments.length;
10568    args = new Array(len - 1);
10569    for (i = 1; i < len; i++)
10570      args[i - 1] = arguments[i];
10571
10572    listeners = handler.slice();
10573    len = listeners.length;
10574    for (i = 0; i < len; i++)
10575      listeners[i].apply(this, args);
10576  }
10577
10578  return true;
10579};
10580
10581EventEmitter.prototype.addListener = function(type, listener) {
10582  var m;
10583
10584  if (!isFunction(listener))
10585    throw TypeError('listener must be a function');
10586
10587  if (!this._events)
10588    this._events = {};
10589  if (this._events.newListener)
10590    this.emit('newListener', type,
10591              isFunction(listener.listener) ?
10592              listener.listener : listener);
10593
10594  if (!this._events[type])
10595    this._events[type] = listener;
10596  else if (isObject(this._events[type]))
10597    this._events[type].push(listener);
10598  else
10599    this._events[type] = [this._events[type], listener];
10600  if (isObject(this._events[type]) && !this._events[type].warned) {
10601    var m;
10602    if (!isUndefined(this._maxListeners)) {
10603      m = this._maxListeners;
10604    } else {
10605      m = EventEmitter.defaultMaxListeners;
10606    }
10607
10608    if (m && m > 0 && this._events[type].length > m) {
10609      this._events[type].warned = true;
10610      console.error('(node) warning: possible EventEmitter memory ' +
10611                    'leak detected. %d listeners added. ' +
10612                    'Use emitter.setMaxListeners() to increase limit.',
10613                    this._events[type].length);
10614      console.trace();
10615    }
10616  }
10617
10618  return this;
10619};
10620
10621EventEmitter.prototype.on = EventEmitter.prototype.addListener;
10622
10623EventEmitter.prototype.once = function(type, listener) {
10624  if (!isFunction(listener))
10625    throw TypeError('listener must be a function');
10626
10627  var fired = false;
10628
10629  function g() {
10630    this.removeListener(type, g);
10631
10632    if (!fired) {
10633      fired = true;
10634      listener.apply(this, arguments);
10635    }
10636  }
10637
10638  g.listener = listener;
10639  this.on(type, g);
10640
10641  return this;
10642};
10643EventEmitter.prototype.removeListener = function(type, listener) {
10644  var list, position, length, i;
10645
10646  if (!isFunction(listener))
10647    throw TypeError('listener must be a function');
10648
10649  if (!this._events || !this._events[type])
10650    return this;
10651
10652  list = this._events[type];
10653  length = list.length;
10654  position = -1;
10655
10656  if (list === listener ||
10657      (isFunction(list.listener) && list.listener === listener)) {
10658    delete this._events[type];
10659    if (this._events.removeListener)

10660      this.emit('removeListener', type, listener);
10661
10662  } else if (isObject(list)) {
10663    for (i = length; i-- > 0;) {
10664      if (list[i] === listener ||
10665          (list[i].listener && list[i].listener === listener)) {
10666        position = i;
10667        break;
10668      }
10669    }
10670
10671    if (position < 0)
10672      return this;
10673
10674    if (list.length === 1) {
10675      list.length = 0;
10676      delete this._events[type];
10677    } else {
10678      list.splice(position, 1);
10679    }
10680
10681    if (this._events.removeListener)
10682      this.emit('removeListener', type, listener);
10683  }
10684
10685  return this;
10686};
10687
10688EventEmitter.prototype.removeAllListeners = function(type) {
10689  var key, listeners;
10690
10691  if (!this._events)
10692    return this;
10693  if (!this._events.removeListener) {
10694    if (arguments.length === 0)
10695      this._events = {};
10696    else if (this._events[type])
10697      delete this._events[type];
10698    return this;
10699  }
10700  if (arguments.length === 0) {
10701    for (key in this._events) {
10702      if (key === 'removeListener') continue;
10703      this.removeAllListeners(key);
10704    }
10705    this.removeAllListeners('removeListener');
10706    this._events = {};
10707    return this;
10708  }
10709
10710  listeners = this._events[type];
10711
10712  if (isFunction(listeners)) {
10713    this.removeListener(type, listeners);
10714  } else {
10715    while (listeners.length)
10716      this.removeListener(type, listeners[listeners.length - 1]);
10717  }
10718  delete this._events[type];
10719
10720  return this;
10721};
10722
10723EventEmitter.prototype.listeners = function(type) {
10724  var ret;
10725  if (!this._events || !this._events[type])
10726    ret = [];
10727  else if (isFunction(this._events[type]))
10728    ret = [this._events[type]];
10729  else
10730    ret = this._events[type].slice();
10731  return ret;
10732};
10733
10734EventEmitter.listenerCount = function(emitter, type) {
10735  var ret;
10736  if (!emitter._events || !emitter._events[type])
10737    ret = 0;
10738  else if (isFunction(emitter._events[type]))
10739    ret = 1;
10740  else
10741    ret = emitter._events[type].length;
10742  return ret;
10743};
10744
10745function isFunction(arg) {
10746  return typeof arg === 'function';
10747}
10748
10749function isNumber(arg) {
10750  return typeof arg === 'number';
10751}
10752
10753function isObject(arg) {
10754  return typeof arg === 'object' && arg !== null;
10755}
10756
10757function isUndefined(arg) {
10758  return arg === void 0;
10759}
10760
10761},
10762{}],
1076317:[function(_dereq_,module,exports){
10764if (typeof Object.create === 'function') {
10765  module.exports = function inherits(ctor, superCtor) {
10766    ctor.super_ = superCtor
10767    ctor.prototype = Object.create(superCtor.prototype, {
10768      constructor: {
10769        value: ctor,
10770        enumerable: false,
10771        writable: true,
10772        configurable: true
10773      }
10774    });
10775  };
10776} else {
10777  module.exports = function inherits(ctor, superCtor) {
10778    ctor.super_ = superCtor
10779    var TempCtor = function () {}
10780    TempCtor.prototype = superCtor.prototype
10781    ctor.prototype = new TempCtor()
10782    ctor.prototype.constructor = ctor
10783  }
10784}
10785
10786},
10787{}],
1078818:[function(_dereq_,module,exports){
10789
10790var process = module.exports = {};
10791
10792process.nextTick = (function () {
10793    var canSetImmediate = typeof window !== 'undefined'
10794    && window.setImmediate;
10795    var canPost = typeof window !== 'undefined'
10796    && window.postMessage && window.addEventListener
10797    ;
10798
10799    if (canSetImmediate) {
10800        return function (f) { return window.setImmediate(f) };
10801    }
10802
10803    if (canPost) {
10804        var queue = [];
10805        window.addEventListener('message', function (ev) {
10806            var source = ev.source;
10807            if ((source === window || source === null) && ev.data === 'process-tick') {
10808                ev.stopPropagation();
10809                if (queue.length > 0) {
10810                    var fn = queue.shift();
10811                    fn();
10812                }
10813            }
10814        }, true);
10815
10816        return function nextTick(fn) {
10817            queue.push(fn);
10818            window.postMessage('process-tick', '*');
10819        };
10820    }
10821
10822    return function nextTick(fn) {
10823        setTimeout(fn, 0);
10824    };
10825})();
10826
10827process.title = 'browser';
10828process.browser = true;
10829process.env = {};
10830process.argv = [];
10831
10832function noop() {}
10833
10834process.on = noop;
10835process.once = noop;
10836process.off = noop;
10837process.emit = noop;
10838
10839process.binding = function (name) {
10840    throw new Error('process.binding is not supported');
10841}
10842process.cwd = function () { return '/' };
10843process.chdir = function (dir) {
10844    throw new Error('process.chdir is not supported');
10845};
10846
10847},
10848{}],
1084919:[function(_dereq_,module,exports){
10850module.exports=_dereq_(14)
10851},
10852{}],
1085320:[function(_dereq_,module,exports){
10854module.exports=_dereq_(15)
10855},
10856{"./support/isBuffer":19,"/usr/local/lib/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":18,"inherits":17}]},{},[9])
10857(9)
10858
10859}

10859);
10860
10861define("ace/mode/html_worker",[], function(require, exports, module) {
10862"use strict";
10863
10864var oop = require("../lib/oop");
10865var lang = require("../lib/lang");
10866var Mirror = require("../worker/mirror").Mirror;
10867var SAXParser = require("./html/saxparser").SAXParser;
10868
10869var errorTypes = {
10870    "expected-doctype-but-got-start-tag": "info",
10871    "expected-doctype-but-got-chars": "info",
10872    "non-html-root": "info"
10873};
10874
10875var Worker = exports.Worker = function(sender) {
10876    Mirror.call(this, sender);
10877    this.setTimeout(400);
10878    this.context = null;
10879};
10880
10881oop.inherits(Worker, Mirror);
10882
10883(function() {
10884
10885    this.setOptions = function(options) {
10886        this.context = options.context;
10887    };
10888
10889    this.onUpdate = function() {
10890        var value = this.doc.getValue();
10891        if (!value)
10892            return;
10893        var parser = new SAXParser();
10894        var errors = [];
10895        var noop = function(){};
10896        parser.contentHandler = {
10897           startDocument: noop,
10898           endDocument: noop,
10899           startElement: noop,
10900           endElement: noop,
10901           characters: noop
10902        };
10903        parser.errorHandler = {
10904            error: function(message, location, code) {
10905                errors.push({
10906                    row: location.line,
10907                    column: location.column,
10908                    text: message,
10909                    type: errorTypes[code] || "error"
10910                });
10911            }
10912        };
10913        if (this.context)
10914            parser.parseFragment(value, this.context);
10915        else
10916            parser.parse(value);
10917        this.sender.emit("error", errors);
10918    };
10919
10920}).call(Worker.prototype);
10921
10922});

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.