corrade-nucleus-nucleons – Blame information for rev 24
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
20 | office | 1 | "no use strict"; |
2 | ;(function(window) { |
||
3 | if (typeof window.window != "undefined" && window.document) |
||
4 | return; |
||
5 | if (window.require && window.define) |
||
6 | return; |
||
7 | |||
8 | if (!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 | } |
||
18 | window.window = window; |
||
19 | window.ace = window; |
||
20 | |||
21 | window.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 | |||
32 | window.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 | |||
52 | window.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 | }; |
||
82 | function 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 | } |
||
100 | window.require.modules = {}; |
||
101 | window.require.tlns = {}; |
||
102 | |||
103 | window.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.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 | }; |
||
155 | window.define.amd = {}; |
||
156 | require.tlns = {}; |
||
157 | window.initBaseUrls = function initBaseUrls(topLevelNamespaces) { |
||
158 | for (var i in topLevelNamespaces) |
||
159 | require.tlns[i] = topLevelNamespaces[i]; |
||
160 | }; |
||
161 | |||
162 | window.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 | |||
194 | var main = window.main = null; |
||
195 | var sender = window.sender = null; |
||
196 | |||
197 | window.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 | require("ace/lib/es5-shim"); |
||
213 | sender = window.sender = window.initSender(); |
||
214 | var clazz = require(msg.module)[msg.classname]; |
||
215 | main = window.main = new clazz(sender); |
||
216 | } |
||
217 | }; |
||
218 | })(this); |
||
219 | |||
220 | ace.define("ace/lib/oop",["require","exports","module"], function(require, exports, module) { |
||
221 | "use strict"; |
||
222 | |||
223 | exports.inherits = function(ctor, superCtor) { |
||
224 | ctor.super_ = superCtor; |
||
225 | ctor.prototype = Object.create(superCtor.prototype, { |
||
226 | constructor: { |
||
227 | value: ctor, |
||
228 | enumerable: false, |
||
229 | writable: true, |
||
230 | configurable: true |
||
231 | } |
||
232 | }); |
||
233 | }; |
||
234 | |||
235 | exports.mixin = function(obj, mixin) { |
||
236 | for (var key in mixin) { |
||
237 | obj[key] = mixin[key]; |
||
238 | } |
||
239 | return obj; |
||
240 | }; |
||
241 | |||
242 | exports.implement = function(proto, mixin) { |
||
243 | exports.mixin(proto, mixin); |
||
244 | }; |
||
245 | |||
246 | }); |
||
247 | |||
248 | ace.define("ace/lib/lang",["require","exports","module"], function(require, exports, module) { |
||
249 | "use strict"; |
||
250 | |||
251 | exports.last = function(a) { |
||
252 | return a[a.length - 1]; |
||
253 | }; |
||
254 | |||
255 | exports.stringReverse = function(string) { |
||
256 | return string.split("").reverse().join(""); |
||
257 | }; |
||
258 | |||
259 | exports.stringRepeat = function (string, count) { |
||
260 | var result = ''; |
||
261 | while (count > 0) { |
||
262 | if (count & 1) |
||
263 | result += string; |
||
264 | |||
265 | if (count >>= 1) |
||
266 | string += string; |
||
267 | } |
||
268 | return result; |
||
269 | }; |
||
270 | |||
271 | var trimBeginRegexp = /^\s\s*/; |
||
272 | var trimEndRegexp = /\s\s*$/; |
||
273 | |||
274 | exports.stringTrimLeft = function (string) { |
||
275 | return string.replace(trimBeginRegexp, ''); |
||
276 | }; |
||
277 | |||
278 | exports.stringTrimRight = function (string) { |
||
279 | return string.replace(trimEndRegexp, ''); |
||
280 | }; |
||
281 | |||
282 | exports.copyObject = function(obj) { |
||
283 | var copy = {}; |
||
284 | for (var key in obj) { |
||
285 | copy[key] = obj[key]; |
||
286 | } |
||
287 | return copy; |
||
288 | }; |
||
289 | |||
290 | exports.copyArray = function(array){ |
||
291 | var copy = []; |
||
292 | for (var i=0, l=array.length; i<l; i++) { |
||
293 | if (array[i] && typeof array[i] == "object") |
||
294 | copy[i] = this.copyObject(array[i]); |
||
295 | else |
||
296 | copy[i] = array[i]; |
||
297 | } |
||
298 | return copy; |
||
299 | }; |
||
300 | |||
301 | exports.deepCopy = function deepCopy(obj) { |
||
302 | if (typeof obj !== "object" || !obj) |
||
303 | return obj; |
||
304 | var copy; |
||
305 | if (Array.isArray(obj)) { |
||
306 | copy = []; |
||
307 | for (var key = 0; key < obj.length; key++) { |
||
308 | copy[key] = deepCopy(obj[key]); |
||
309 | } |
||
310 | return copy; |
||
311 | } |
||
312 | if (Object.prototype.toString.call(obj) !== "[object Object]") |
||
313 | return obj; |
||
314 | |||
315 | copy = {}; |
||
316 | for (var key in obj) |
||
317 | copy[key] = deepCopy(obj[key]); |
||
318 | return copy; |
||
319 | }; |
||
320 | |||
321 | exports.arrayToMap = function(arr) { |
||
322 | var map = {}; |
||
323 | for (var i=0; i<arr.length; i++) { |
||
324 | map[arr[i]] = 1; |
||
325 | } |
||
326 | return map; |
||
327 | |||
328 | }; |
||
329 | |||
330 | exports.createMap = function(props) { |
||
331 | var map = Object.create(null); |
||
332 | for (var i in props) { |
||
333 | map[i] = props[i]; |
||
334 | } |
||
335 | return map; |
||
336 | }; |
||
337 | exports.arrayRemove = function(array, value) { |
||
338 | for (var i = 0; i <= array.length; i++) { |
||
339 | if (value === array[i]) { |
||
340 | array.splice(i, 1); |
||
341 | } |
||
342 | } |
||
343 | }; |
||
344 | |||
345 | exports.escapeRegExp = function(str) { |
||
346 | return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1'); |
||
347 | }; |
||
348 | |||
349 | exports.escapeHTML = function(str) { |
||
350 | return str.replace(/&/g, "&").replace(/"/g, """).replace(/'/g, "'").replace(/g, "<"); |
||
351 | }; |
||
352 | |||
353 | exports.getMatchOffsets = function(string, regExp) { |
||
354 | var matches = []; |
||
355 | |||
356 | string.replace(regExp, function(str) { |
||
357 | matches.push({ |
||
358 | offset: arguments[arguments.length-2], |
||
359 | length: str.length |
||
360 | }); |
||
361 | }); |
||
362 | |||
363 | return matches; |
||
364 | }; |
||
365 | exports.deferredCall = function(fcn) { |
||
366 | var timer = null; |
||
367 | var callback = function() { |
||
368 | timer = null; |
||
369 | fcn(); |
||
370 | }; |
||
371 | |||
372 | var deferred = function(timeout) { |
||
373 | deferred.cancel(); |
||
374 | timer = setTimeout(callback, timeout || 0); |
||
375 | return deferred; |
||
376 | }; |
||
377 | |||
378 | deferred.schedule = deferred; |
||
379 | |||
380 | deferred.call = function() { |
||
381 | this.cancel(); |
||
382 | fcn(); |
||
383 | return deferred; |
||
384 | }; |
||
385 | |||
386 | deferred.cancel = function() { |
||
387 | clearTimeout(timer); |
||
388 | timer = null; |
||
389 | return deferred; |
||
390 | }; |
||
391 | |||
392 | deferred.isPending = function() { |
||
393 | return timer; |
||
394 | }; |
||
395 | |||
396 | return deferred; |
||
397 | }; |
||
398 | |||
399 | |||
400 | exports.delayedCall = function(fcn, defaultTimeout) { |
||
401 | var timer = null; |
||
402 | var callback = function() { |
||
403 | timer = null; |
||
404 | fcn(); |
||
405 | }; |
||
406 | |||
407 | var _self = function(timeout) { |
||
408 | if (timer == null) |
||
409 | timer = setTimeout(callback, timeout || defaultTimeout); |
||
410 | }; |
||
411 | |||
412 | _self.delay = function(timeout) { |
||
413 | timer && clearTimeout(timer); |
||
414 | timer = setTimeout(callback, timeout || defaultTimeout); |
||
415 | }; |
||
416 | _self.schedule = _self; |
||
417 | |||
418 | _self.call = function() { |
||
419 | this.cancel(); |
||
420 | fcn(); |
||
421 | }; |
||
422 | |||
423 | _self.cancel = function() { |
||
424 | timer && clearTimeout(timer); |
||
425 | timer = null; |
||
426 | }; |
||
427 | |||
428 | _self.isPending = function() { |
||
429 | return timer; |
||
430 | }; |
||
431 | |||
432 | return _self; |
||
433 | }; |
||
434 | }); |
||
435 | |||
436 | ace.define("ace/range",["require","exports","module"], function(require, exports, module) { |
||
437 | "use strict"; |
||
438 | var comparePoints = function(p1, p2) { |
||
439 | return p1.row - p2.row || p1.column - p2.column; |
||
440 | }; |
||
441 | var Range = function(startRow, startColumn, endRow, endColumn) { |
||
442 | this.start = { |
||
443 | row: startRow, |
||
444 | column: startColumn |
||
445 | }; |
||
446 | |||
447 | this.end = { |
||
448 | row: endRow, |
||
449 | column: endColumn |
||
450 | }; |
||
451 | }; |
||
452 | |||
453 | (function() { |
||
454 | this.isEqual = function(range) { |
||
455 | return this.start.row === range.start.row && |
||
456 | this.end.row === range.end.row && |
||
457 | this.start.column === range.start.column && |
||
458 | this.end.column === range.end.column; |
||
459 | }; |
||
460 | this.toString = function() { |
||
461 | return ("Range: [" + this.start.row + "/" + this.start.column + |
||
462 | "] -> [" + this.end.row + "/" + this.end.column + "]"); |
||
463 | }; |
||
464 | |||
465 | this.contains = function(row, column) { |
||
466 | return this.compare(row, column) == 0; |
||
467 | }; |
||
468 | this.compareRange = function(range) { |
||
469 | var cmp, |
||
470 | end = range.end, |
||
471 | start = range.start; |
||
472 | |||
473 | cmp = this.compare(end.row, end.column); |
||
474 | if (cmp == 1) { |
||
475 | cmp = this.compare(start.row, start.column); |
||
476 | if (cmp == 1) { |
||
477 | return 2; |
||
478 | } else if (cmp == 0) { |
||
479 | return 1; |
||
480 | } else { |
||
481 | return 0; |
||
482 | } |
||
483 | } else if (cmp == -1) { |
||
484 | return -2; |
||
485 | } else { |
||
486 | cmp = this.compare(start.row, start.column); |
||
487 | if (cmp == -1) { |
||
488 | return -1; |
||
489 | } else if (cmp == 1) { |
||
490 | return 42; |
||
491 | } else { |
||
492 | return 0; |
||
493 | } |
||
494 | } |
||
495 | }; |
||
496 | this.comparePoint = function(p) { |
||
497 | return this.compare(p.row, p.column); |
||
498 | }; |
||
499 | this.containsRange = function(range) { |
||
500 | return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0; |
||
501 | }; |
||
502 | this.intersects = function(range) { |
||
503 | var cmp = this.compareRange(range); |
||
504 | return (cmp == -1 || cmp == 0 || cmp == 1); |
||
505 | }; |
||
506 | this.isEnd = function(row, column) { |
||
507 | return this.end.row == row && this.end.column == column; |
||
508 | }; |
||
509 | this.isStart = function(row, column) { |
||
510 | return this.start.row == row && this.start.column == column; |
||
511 | }; |
||
512 | this.setStart = function(row, column) { |
||
513 | if (typeof row == "object") { |
||
514 | this.start.column = row.column; |
||
515 | this.start.row = row.row; |
||
516 | } else { |
||
517 | this.start.row = row; |
||
518 | this.start.column = column; |
||
519 | } |
||
520 | }; |
||
521 | this.setEnd = function(row, column) { |
||
522 | if (typeof row == "object") { |
||
523 | this.end.column = row.column; |
||
524 | this.end.row = row.row; |
||
525 | } else { |
||
526 | this.end.row = row; |
||
527 | this.end.column = column; |
||
528 | } |
||
529 | }; |
||
530 | this.inside = function(row, column) { |
||
531 | if (this.compare(row, column) == 0) { |
||
532 | if (this.isEnd(row, column) || this.isStart(row, column)) { |
||
533 | return false; |
||
534 | } else { |
||
535 | return true; |
||
536 | } |
||
537 | } |
||
538 | return false; |
||
539 | }; |
||
540 | this.insideStart = function(row, column) { |
||
541 | if (this.compare(row, column) == 0) { |
||
542 | if (this.isEnd(row, column)) { |
||
543 | return false; |
||
544 | } else { |
||
545 | return true; |
||
546 | } |
||
547 | } |
||
548 | return false; |
||
549 | }; |
||
550 | this.insideEnd = function(row, column) { |
||
551 | if (this.compare(row, column) == 0) { |
||
552 | if (this.isStart(row, column)) { |
||
553 | return false; |
||
554 | } else { |
||
555 | return true; |
||
556 | } |
||
557 | } |
||
558 | return false; |
||
559 | }; |
||
560 | this.compare = function(row, column) { |
||
561 | if (!this.isMultiLine()) { |
||
562 | if (row === this.start.row) { |
||
563 | return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0); |
||
564 | } |
||
565 | } |
||
566 | |||
567 | if (row < this.start.row) |
||
568 | return -1; |
||
569 | |||
570 | if (row > this.end.row) |
||
571 | return 1; |
||
572 | |||
573 | if (this.start.row === row) |
||
574 | return column >= this.start.column ? 0 : -1; |
||
575 | |||
576 | if (this.end.row === row) |
||
577 | return column <= this.end.column ? 0 : 1; |
||
578 | |||
579 | return 0; |
||
580 | }; |
||
581 | this.compareStart = function(row, column) { |
||
582 | if (this.start.row == row && this.start.column == column) { |
||
583 | return -1; |
||
584 | } else { |
||
585 | return this.compare(row, column); |
||
586 | } |
||
587 | }; |
||
588 | this.compareEnd = function(row, column) { |
||
589 | if (this.end.row == row && this.end.column == column) { |
||
590 | return 1; |
||
591 | } else { |
||
592 | return this.compare(row, column); |
||
593 | } |
||
594 | }; |
||
595 | this.compareInside = function(row, column) { |
||
596 | if (this.end.row == row && this.end.column == column) { |
||
597 | return 1; |
||
598 | } else if (this.start.row == row && this.start.column == column) { |
||
599 | return -1; |
||
600 | } else { |
||
601 | return this.compare(row, column); |
||
602 | } |
||
603 | }; |
||
604 | this.clipRows = function(firstRow, lastRow) { |
||
605 | if (this.end.row > lastRow) |
||
606 | var end = {row: lastRow + 1, column: 0}; |
||
607 | else if (this.end.row < firstRow) |
||
608 | var end = {row: firstRow, column: 0}; |
||
609 | |||
610 | if (this.start.row > lastRow) |
||
611 | var start = {row: lastRow + 1, column: 0}; |
||
612 | else if (this.start.row < firstRow) |
||
613 | var start = {row: firstRow, column: 0}; |
||
614 | |||
615 | return Range.fromPoints(start || this.start, end || this.end); |
||
616 | }; |
||
617 | this.extend = function(row, column) { |
||
618 | var cmp = this.compare(row, column); |
||
619 | |||
620 | if (cmp == 0) |
||
621 | return this; |
||
622 | else if (cmp == -1) |
||
623 | var start = {row: row, column: column}; |
||
624 | else |
||
625 | var end = {row: row, column: column}; |
||
626 | |||
627 | return Range.fromPoints(start || this.start, end || this.end); |
||
628 | }; |
||
629 | |||
630 | this.isEmpty = function() { |
||
631 | return (this.start.row === this.end.row && this.start.column === this.end.column); |
||
632 | }; |
||
633 | this.isMultiLine = function() { |
||
634 | return (this.start.row !== this.end.row); |
||
635 | }; |
||
636 | this.clone = function() { |
||
637 | return Range.fromPoints(this.start, this.end); |
||
638 | }; |
||
639 | this.collapseRows = function() { |
||
640 | if (this.end.column == 0) |
||
641 | return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row-1), 0) |
||
642 | else |
||
643 | return new Range(this.start.row, 0, this.end.row, 0) |
||
644 | }; |
||
645 | this.toScreenRange = function(session) { |
||
646 | var screenPosStart = session.documentToScreenPosition(this.start); |
||
647 | var screenPosEnd = session.documentToScreenPosition(this.end); |
||
648 | |||
649 | return new Range( |
||
650 | screenPosStart.row, screenPosStart.column, |
||
651 | screenPosEnd.row, screenPosEnd.column |
||
652 | ); |
||
653 | }; |
||
654 | this.moveBy = function(row, column) { |
||
655 | this.start.row += row; |
||
656 | this.start.column += column; |
||
657 | this.end.row += row; |
||
658 | this.end.column += column; |
||
659 | }; |
||
660 | |||
661 | }).call(Range.prototype); |
||
662 | Range.fromPoints = function(start, end) { |
||
663 | return new Range(start.row, start.column, end.row, end.column); |
||
664 | }; |
||
665 | Range.comparePoints = comparePoints; |
||
666 | |||
667 | Range.comparePoints = function(p1, p2) { |
||
668 | return p1.row - p2.row || p1.column - p2.column; |
||
669 | }; |
||
670 | |||
671 | |||
672 | exports.Range = Range; |
||
673 | }); |
||
674 | |||
675 | ace.define("ace/apply_delta",["require","exports","module"], function(require, exports, module) { |
||
676 | "use strict"; |
||
677 | |||
678 | function throwDeltaError(delta, errorText){ |
||
679 | console.log("Invalid Delta:", delta); |
||
680 | throw "Invalid Delta: " + errorText; |
||
681 | } |
||
682 | |||
683 | function positionInDocument(docLines, position) { |
||
684 | return position.row >= 0 && position.row < docLines.length && |
||
685 | position.column >= 0 && position.column <= docLines[position.row].length; |
||
686 | } |
||
687 | |||
688 | function validateDelta(docLines, delta) { |
||
689 | if (delta.action != "insert" && delta.action != "remove") |
||
690 | throwDeltaError(delta, "delta.action must be 'insert' or 'remove'"); |
||
691 | if (!(delta.lines instanceof Array)) |
||
692 | throwDeltaError(delta, "delta.lines must be an Array"); |
||
693 | if (!delta.start || !delta.end) |
||
694 | throwDeltaError(delta, "delta.start/end must be an present"); |
||
695 | var start = delta.start; |
||
696 | if (!positionInDocument(docLines, delta.start)) |
||
697 | throwDeltaError(delta, "delta.start must be contained in document"); |
||
698 | var end = delta.end; |
||
699 | if (delta.action == "remove" && !positionInDocument(docLines, end)) |
||
700 | throwDeltaError(delta, "delta.end must contained in document for 'remove' actions"); |
||
701 | var numRangeRows = end.row - start.row; |
||
702 | var numRangeLastLineChars = (end.column - (numRangeRows == 0 ? start.column : 0)); |
||
703 | if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars) |
||
704 | throwDeltaError(delta, "delta.range must match delta lines"); |
||
705 | } |
||
706 | |||
707 | exports.applyDelta = function(docLines, delta, doNotValidate) { |
||
708 | |||
709 | var row = delta.start.row; |
||
710 | var startColumn = delta.start.column; |
||
711 | var line = docLines[row] || ""; |
||
712 | switch (delta.action) { |
||
713 | case "insert": |
||
714 | var lines = delta.lines; |
||
715 | if (lines.length === 1) { |
||
716 | docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn); |
||
717 | } else { |
||
718 | var args = [row, 1].concat(delta.lines); |
||
719 | docLines.splice.apply(docLines, args); |
||
720 | docLines[row] = line.substring(0, startColumn) + docLines[row]; |
||
721 | docLines[row + delta.lines.length - 1] += line.substring(startColumn); |
||
722 | } |
||
723 | break; |
||
724 | case "remove": |
||
725 | var endColumn = delta.end.column; |
||
726 | var endRow = delta.end.row; |
||
727 | if (row === endRow) { |
||
728 | docLines[row] = line.substring(0, startColumn) + line.substring(endColumn); |
||
729 | } else { |
||
730 | docLines.splice( |
||
731 | row, endRow - row + 1, |
||
732 | line.substring(0, startColumn) + docLines[endRow].substring(endColumn) |
||
733 | ); |
||
734 | } |
||
735 | break; |
||
736 | } |
||
737 | } |
||
738 | }); |
||
739 | |||
740 | ace.define("ace/lib/event_emitter",["require","exports","module"], function(require, exports, module) { |
||
741 | "use strict"; |
||
742 | |||
743 | var EventEmitter = {}; |
||
744 | var stopPropagation = function() { this.propagationStopped = true; }; |
||
745 | var preventDefault = function() { this.defaultPrevented = true; }; |
||
746 | |||
747 | EventEmitter._emit = |
||
748 | EventEmitter._dispatchEvent = function(eventName, e) { |
||
749 | this._eventRegistry || (this._eventRegistry = {}); |
||
750 | this._defaultHandlers || (this._defaultHandlers = {}); |
||
751 | |||
752 | var listeners = this._eventRegistry[eventName] || []; |
||
753 | var defaultHandler = this._defaultHandlers[eventName]; |
||
754 | if (!listeners.length && !defaultHandler) |
||
755 | return; |
||
756 | |||
757 | if (typeof e != "object" || !e) |
||
758 | e = {}; |
||
759 | |||
760 | if (!e.type) |
||
761 | e.type = eventName; |
||
762 | if (!e.stopPropagation) |
||
763 | e.stopPropagation = stopPropagation; |
||
764 | if (!e.preventDefault) |
||
765 | e.preventDefault = preventDefault; |
||
766 | |||
767 | listeners = listeners.slice(); |
||
768 | for (var i=0; i<listeners.length; i++) { |
||
769 | listeners[i](e, this); |
||
770 | if (e.propagationStopped) |
||
771 | break; |
||
772 | } |
||
773 | |||
774 | if (defaultHandler && !e.defaultPrevented) |
||
775 | return defaultHandler(e, this); |
||
776 | }; |
||
777 | |||
778 | |||
779 | EventEmitter._signal = function(eventName, e) { |
||
780 | var listeners = (this._eventRegistry || {})[eventName]; |
||
781 | if (!listeners) |
||
782 | return; |
||
783 | listeners = listeners.slice(); |
||
784 | for (var i=0; i<listeners.length; i++) |
||
785 | listeners[i](e, this); |
||
786 | }; |
||
787 | |||
788 | EventEmitter.once = function(eventName, callback) { |
||
789 | var _self = this; |
||
790 | callback && this.addEventListener(eventName, function newCallback() { |
||
791 | _self.removeEventListener(eventName, newCallback); |
||
792 | callback.apply(null, arguments); |
||
793 | }); |
||
794 | }; |
||
795 | |||
796 | |||
797 | EventEmitter.setDefaultHandler = function(eventName, callback) { |
||
798 | var handlers = this._defaultHandlers |
||
799 | if (!handlers) |
||
800 | handlers = this._defaultHandlers = {_disabled_: {}}; |
||
801 | |||
802 | if (handlers[eventName]) { |
||
803 | var old = handlers[eventName]; |
||
804 | var disabled = handlers._disabled_[eventName]; |
||
805 | if (!disabled) |
||
806 | handlers._disabled_[eventName] = disabled = []; |
||
807 | disabled.push(old); |
||
808 | var i = disabled.indexOf(callback); |
||
809 | if (i != -1) |
||
810 | disabled.splice(i, 1); |
||
811 | } |
||
812 | handlers[eventName] = callback; |
||
813 | }; |
||
814 | EventEmitter.removeDefaultHandler = function(eventName, callback) { |
||
815 | var handlers = this._defaultHandlers |
||
816 | if (!handlers) |
||
817 | return; |
||
818 | var disabled = handlers._disabled_[eventName]; |
||
819 | |||
820 | if (handlers[eventName] == callback) { |
||
821 | var old = handlers[eventName]; |
||
822 | if (disabled) |
||
823 | this.setDefaultHandler(eventName, disabled.pop()); |
||
824 | } else if (disabled) { |
||
825 | var i = disabled.indexOf(callback); |
||
826 | if (i != -1) |
||
827 | disabled.splice(i, 1); |
||
828 | } |
||
829 | }; |
||
830 | |||
831 | EventEmitter.on = |
||
832 | EventEmitter.addEventListener = function(eventName, callback, capturing) { |
||
833 | this._eventRegistry = this._eventRegistry || {}; |
||
834 | |||
835 | var listeners = this._eventRegistry[eventName]; |
||
836 | if (!listeners) |
||
837 | listeners = this._eventRegistry[eventName] = []; |
||
838 | |||
839 | if (listeners.indexOf(callback) == -1) |
||
840 | listeners[capturing ? "unshift" : "push"](callback); |
||
841 | return callback; |
||
842 | }; |
||
843 | |||
844 | EventEmitter.off = |
||
845 | EventEmitter.removeListener = |
||
846 | EventEmitter.removeEventListener = function(eventName, callback) { |
||
847 | this._eventRegistry = this._eventRegistry || {}; |
||
848 | |||
849 | var listeners = this._eventRegistry[eventName]; |
||
850 | if (!listeners) |
||
851 | return; |
||
852 | |||
853 | var index = listeners.indexOf(callback); |
||
854 | if (index !== -1) |
||
855 | listeners.splice(index, 1); |
||
856 | }; |
||
857 | |||
858 | EventEmitter.removeAllListeners = function(eventName) { |
||
859 | if (this._eventRegistry) this._eventRegistry[eventName] = []; |
||
860 | }; |
||
861 | |||
862 | exports.EventEmitter = EventEmitter; |
||
863 | |||
864 | }); |
||
865 | |||
866 | ace.define("ace/anchor",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"], function(require, exports, module) { |
||
867 | "use strict"; |
||
868 | |||
869 | var oop = require("./lib/oop"); |
||
870 | var EventEmitter = require("./lib/event_emitter").EventEmitter; |
||
871 | |||
872 | var Anchor = exports.Anchor = function(doc, row, column) { |
||
873 | this.$onChange = this.onChange.bind(this); |
||
874 | this.attach(doc); |
||
875 | |||
876 | if (typeof column == "undefined") |
||
877 | this.setPosition(row.row, row.column); |
||
878 | else |
||
879 | this.setPosition(row, column); |
||
880 | }; |
||
881 | |||
882 | (function() { |
||
883 | |||
884 | oop.implement(this, EventEmitter); |
||
885 | this.getPosition = function() { |
||
886 | return this.$clipPositionToDocument(this.row, this.column); |
||
887 | }; |
||
888 | this.getDocument = function() { |
||
889 | return this.document; |
||
890 | }; |
||
891 | this.$insertRight = false; |
||
892 | this.onChange = function(delta) { |
||
893 | if (delta.start.row == delta.end.row && delta.start.row != this.row) |
||
894 | return; |
||
895 | |||
896 | if (delta.start.row > this.row) |
||
897 | return; |
||
898 | |||
899 | var point = $getTransformedPoint(delta, {row: this.row, column: this.column}, this.$insertRight); |
||
900 | this.setPosition(point.row, point.column, true); |
||
901 | }; |
||
902 | |||
903 | function $pointsInOrder(point1, point2, equalPointsInOrder) { |
||
904 | var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column; |
||
905 | return (point1.row < point2.row) || (point1.row == point2.row && bColIsAfter); |
||
906 | } |
||
907 | |||
908 | function $getTransformedPoint(delta, point, moveIfEqual) { |
||
909 | var deltaIsInsert = delta.action == "insert"; |
||
910 | var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row - delta.start.row); |
||
911 | var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column); |
||
912 | var deltaStart = delta.start; |
||
913 | var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range. |
||
914 | if ($pointsInOrder(point, deltaStart, moveIfEqual)) { |
||
915 | return { |
||
916 | row: point.row, |
||
917 | column: point.column |
||
918 | }; |
||
919 | } |
||
920 | if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) { |
||
921 | return { |
||
922 | row: point.row + deltaRowShift, |
||
923 | column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0) |
||
924 | }; |
||
925 | } |
||
926 | |||
927 | return { |
||
928 | row: deltaStart.row, |
||
929 | column: deltaStart.column |
||
930 | }; |
||
931 | } |
||
932 | this.setPosition = function(row, column, noClip) { |
||
933 | var pos; |
||
934 | if (noClip) { |
||
935 | pos = { |
||
936 | row: row, |
||
937 | column: column |
||
938 | }; |
||
939 | } else { |
||
940 | pos = this.$clipPositionToDocument(row, column); |
||
941 | } |
||
942 | |||
943 | if (this.row == pos.row && this.column == pos.column) |
||
944 | return; |
||
945 | |||
946 | var old = { |
||
947 | row: this.row, |
||
948 | column: this.column |
||
949 | }; |
||
950 | |||
951 | this.row = pos.row; |
||
952 | this.column = pos.column; |
||
953 | this._signal("change", { |
||
954 | old: old, |
||
955 | value: pos |
||
956 | }); |
||
957 | }; |
||
958 | this.detach = function() { |
||
959 | this.document.removeEventListener("change", this.$onChange); |
||
960 | }; |
||
961 | this.attach = function(doc) { |
||
962 | this.document = doc || this.document; |
||
963 | this.document.on("change", this.$onChange); |
||
964 | }; |
||
965 | this.$clipPositionToDocument = function(row, column) { |
||
966 | var pos = {}; |
||
967 | |||
968 | if (row >= this.document.getLength()) { |
||
969 | pos.row = Math.max(0, this.document.getLength() - 1); |
||
970 | pos.column = this.document.getLine(pos.row).length; |
||
971 | } |
||
972 | else if (row < 0) { |
||
973 | pos.row = 0; |
||
974 | pos.column = 0; |
||
975 | } |
||
976 | else { |
||
977 | pos.row = row; |
||
978 | pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column)); |
||
979 | } |
||
980 | |||
981 | if (column < 0) |
||
982 | pos.column = 0; |
||
983 | |||
984 | return pos; |
||
985 | }; |
||
986 | |||
987 | }).call(Anchor.prototype); |
||
988 | |||
989 | }); |
||
990 | |||
991 | ace.define("ace/document",["require","exports","module","ace/lib/oop","ace/apply_delta","ace/lib/event_emitter","ace/range","ace/anchor"], function(require, exports, module) { |
||
992 | "use strict"; |
||
993 | |||
994 | var oop = require("./lib/oop"); |
||
995 | var applyDelta = require("./apply_delta").applyDelta; |
||
996 | var EventEmitter = require("./lib/event_emitter").EventEmitter; |
||
997 | var Range = require("./range").Range; |
||
998 | var Anchor = require("./anchor").Anchor; |
||
999 | |||
1000 | var Document = function(textOrLines) { |
||
1001 | this.$lines = [""]; |
||
1002 | if (textOrLines.length === 0) { |
||
1003 | this.$lines = [""]; |
||
1004 | } else if (Array.isArray(textOrLines)) { |
||
1005 | this.insertMergedLines({row: 0, column: 0}, textOrLines); |
||
1006 | } else { |
||
1007 | this.insert({row: 0, column:0}, textOrLines); |
||
1008 | } |
||
1009 | }; |
||
1010 | |||
1011 | (function() { |
||
1012 | |||
1013 | oop.implement(this, EventEmitter); |
||
1014 | this.setValue = function(text) { |
||
1015 | var len = this.getLength() - 1; |
||
1016 | this.remove(new Range(0, 0, len, this.getLine(len).length)); |
||
1017 | this.insert({row: 0, column: 0}, text); |
||
1018 | }; |
||
1019 | this.getValue = function() { |
||
1020 | return this.getAllLines().join(this.getNewLineCharacter()); |
||
1021 | }; |
||
1022 | this.createAnchor = function(row, column) { |
||
1023 | return new Anchor(this, row, column); |
||
1024 | }; |
||
1025 | if ("aaa".split(/a/).length === 0) { |
||
1026 | this.$split = function(text) { |
||
1027 | return text.replace(/\r\n|\r/g, "\n").split("\n"); |
||
1028 | }; |
||
1029 | } else { |
||
1030 | this.$split = function(text) { |
||
1031 | return text.split(/\r\n|\r|\n/); |
||
1032 | }; |
||
1033 | } |
||
1034 | |||
1035 | |||
1036 | this.$detectNewLine = function(text) { |
||
1037 | var match = text.match(/^.*?(\r\n|\r|\n)/m); |
||
1038 | this.$autoNewLine = match ? match[1] : "\n"; |
||
1039 | this._signal("changeNewLineMode"); |
||
1040 | }; |
||
1041 | this.getNewLineCharacter = function() { |
||
1042 | switch (this.$newLineMode) { |
||
1043 | case "windows": |
||
1044 | return "\r\n"; |
||
1045 | case "unix": |
||
1046 | return "\n"; |
||
1047 | default: |
||
1048 | return this.$autoNewLine || "\n"; |
||
1049 | } |
||
1050 | }; |
||
1051 | |||
1052 | this.$autoNewLine = ""; |
||
1053 | this.$newLineMode = "auto"; |
||
1054 | this.setNewLineMode = function(newLineMode) { |
||
1055 | if (this.$newLineMode === newLineMode) |
||
1056 | return; |
||
1057 | |||
1058 | this.$newLineMode = newLineMode; |
||
1059 | this._signal("changeNewLineMode"); |
||
1060 | }; |
||
1061 | this.getNewLineMode = function() { |
||
1062 | return this.$newLineMode; |
||
1063 | }; |
||
1064 | this.isNewLine = function(text) { |
||
1065 | return (text == "\r\n" || text == "\r" || text == "\n"); |
||
1066 | }; |
||
1067 | this.getLine = function(row) { |
||
1068 | return this.$lines[row] || ""; |
||
1069 | }; |
||
1070 | this.getLines = function(firstRow, lastRow) { |
||
1071 | return this.$lines.slice(firstRow, lastRow + 1); |
||
1072 | }; |
||
1073 | this.getAllLines = function() { |
||
1074 | return this.getLines(0, this.getLength()); |
||
1075 | }; |
||
1076 | this.getLength = function() { |
||
1077 | return this.$lines.length; |
||
1078 | }; |
||
1079 | this.getTextRange = function(range) { |
||
1080 | return this.getLinesForRange(range).join(this.getNewLineCharacter()); |
||
1081 | }; |
||
1082 | this.getLinesForRange = function(range) { |
||
1083 | var lines; |
||
1084 | if (range.start.row === range.end.row) { |
||
1085 | lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)]; |
||
1086 | } else { |
||
1087 | lines = this.getLines(range.start.row, range.end.row); |
||
1088 | lines[0] = (lines[0] || "").substring(range.start.column); |
||
1089 | var l = lines.length - 1; |
||
1090 | if (range.end.row - range.start.row == l) |
||
1091 | lines[l] = lines[l].substring(0, range.end.column); |
||
1092 | } |
||
1093 | return lines; |
||
1094 | }; |
||
1095 | this.insertLines = function(row, lines) { |
||
1096 | console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead."); |
||
1097 | return this.insertFullLines(row, lines); |
||
1098 | }; |
||
1099 | this.removeLines = function(firstRow, lastRow) { |
||
1100 | console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead."); |
||
1101 | return this.removeFullLines(firstRow, lastRow); |
||
1102 | }; |
||
1103 | this.insertNewLine = function(position) { |
||
1104 | console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead."); |
||
1105 | return this.insertMergedLines(position, ["", ""]); |
||
1106 | }; |
||
1107 | this.insert = function(position, text) { |
||
1108 | if (this.getLength() <= 1) |
||
1109 | this.$detectNewLine(text); |
||
1110 | |||
1111 | return this.insertMergedLines(position, this.$split(text)); |
||
1112 | }; |
||
1113 | this.insertInLine = function(position, text) { |
||
1114 | var start = this.clippedPos(position.row, position.column); |
||
1115 | var end = this.pos(position.row, position.column + text.length); |
||
1116 | |||
1117 | this.applyDelta({ |
||
1118 | start: start, |
||
1119 | end: end, |
||
1120 | action: "insert", |
||
1121 | lines: [text] |
||
1122 | }, true); |
||
1123 | |||
1124 | return this.clonePos(end); |
||
1125 | }; |
||
1126 | |||
1127 | this.clippedPos = function(row, column) { |
||
1128 | var length = this.getLength(); |
||
1129 | if (row === undefined) { |
||
1130 | row = length; |
||
1131 | } else if (row < 0) { |
||
1132 | row = 0; |
||
1133 | } else if (row >= length) { |
||
1134 | row = length - 1; |
||
1135 | column = undefined; |
||
1136 | } |
||
1137 | var line = this.getLine(row); |
||
1138 | if (column == undefined) |
||
1139 | column = line.length; |
||
1140 | column = Math.min(Math.max(column, 0), line.length); |
||
1141 | return {row: row, column: column}; |
||
1142 | }; |
||
1143 | |||
1144 | this.clonePos = function(pos) { |
||
1145 | return {row: pos.row, column: pos.column}; |
||
1146 | }; |
||
1147 | |||
1148 | this.pos = function(row, column) { |
||
1149 | return {row: row, column: column}; |
||
1150 | }; |
||
1151 | |||
1152 | this.$clipPosition = function(position) { |
||
1153 | var length = this.getLength(); |
||
1154 | if (position.row >= length) { |
||
1155 | position.row = Math.max(0, length - 1); |
||
1156 | position.column = this.getLine(length - 1).length; |
||
1157 | } else { |
||
1158 | position.row = Math.max(0, position.row); |
||
1159 | position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length); |
||
1160 | } |
||
1161 | return position; |
||
1162 | }; |
||
1163 | this.insertFullLines = function(row, lines) { |
||
1164 | row = Math.min(Math.max(row, 0), this.getLength()); |
||
1165 | var column = 0; |
||
1166 | if (row < this.getLength()) { |
||
1167 | lines = lines.concat([""]); |
||
1168 | column = 0; |
||
1169 | } else { |
||
1170 | lines = [""].concat(lines); |
||
1171 | row--; |
||
1172 | column = this.$lines[row].length; |
||
1173 | } |
||
1174 | this.insertMergedLines({row: row, column: column}, lines); |
||
1175 | }; |
||
1176 | this.insertMergedLines = function(position, lines) { |
||
1177 | var start = this.clippedPos(position.row, position.column); |
||
1178 | var end = { |
||
1179 | row: start.row + lines.length - 1, |
||
1180 | column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length |
||
1181 | }; |
||
1182 | |||
1183 | this.applyDelta({ |
||
1184 | start: start, |
||
1185 | end: end, |
||
1186 | action: "insert", |
||
1187 | lines: lines |
||
1188 | }); |
||
1189 | |||
1190 | return this.clonePos(end); |
||
1191 | }; |
||
1192 | this.remove = function(range) { |
||
1193 | var start = this.clippedPos(range.start.row, range.start.column); |
||
1194 | var end = this.clippedPos(range.end.row, range.end.column); |
||
1195 | this.applyDelta({ |
||
1196 | start: start, |
||
1197 | end: end, |
||
1198 | action: "remove", |
||
1199 | lines: this.getLinesForRange({start: start, end: end}) |
||
1200 | }); |
||
1201 | return this.clonePos(start); |
||
1202 | }; |
||
1203 | this.removeInLine = function(row, startColumn, endColumn) { |
||
1204 | var start = this.clippedPos(row, startColumn); |
||
1205 | var end = this.clippedPos(row, endColumn); |
||
1206 | |||
1207 | this.applyDelta({ |
||
1208 | start: start, |
||
1209 | end: end, |
||
1210 | action: "remove", |
||
1211 | lines: this.getLinesForRange({start: start, end: end}) |
||
1212 | }, true); |
||
1213 | |||
1214 | return this.clonePos(start); |
||
1215 | }; |
||
1216 | this.removeFullLines = function(firstRow, lastRow) { |
||
1217 | firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1); |
||
1218 | lastRow = Math.min(Math.max(0, lastRow ), this.getLength() - 1); |
||
1219 | var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0; |
||
1220 | var deleteLastNewLine = lastRow < this.getLength() - 1; |
||
1221 | var startRow = ( deleteFirstNewLine ? firstRow - 1 : firstRow ); |
||
1222 | var startCol = ( deleteFirstNewLine ? this.getLine(startRow).length : 0 ); |
||
1223 | var endRow = ( deleteLastNewLine ? lastRow + 1 : lastRow ); |
||
1224 | var endCol = ( deleteLastNewLine ? 0 : this.getLine(endRow).length ); |
||
1225 | var range = new Range(startRow, startCol, endRow, endCol); |
||
1226 | var deletedLines = this.$lines.slice(firstRow, lastRow + 1); |
||
1227 | |||
1228 | this.applyDelta({ |
||
1229 | start: range.start, |
||
1230 | end: range.end, |
||
1231 | action: "remove", |
||
1232 | lines: this.getLinesForRange(range) |
||
1233 | }); |
||
1234 | return deletedLines; |
||
1235 | }; |
||
1236 | this.removeNewLine = function(row) { |
||
1237 | if (row < this.getLength() - 1 && row >= 0) { |
||
1238 | this.applyDelta({ |
||
1239 | start: this.pos(row, this.getLine(row).length), |
||
1240 | end: this.pos(row + 1, 0), |
||
1241 | action: "remove", |
||
1242 | lines: ["", ""] |
||
1243 | }); |
||
1244 | } |
||
1245 | }; |
||
1246 | this.replace = function(range, text) { |
||
1247 | if (!(range instanceof Range)) |
||
1248 | range = Range.fromPoints(range.start, range.end); |
||
1249 | if (text.length === 0 && range.isEmpty()) |
||
1250 | return range.start; |
||
1251 | if (text == this.getTextRange(range)) |
||
1252 | return range.end; |
||
1253 | |||
1254 | this.remove(range); |
||
1255 | var end; |
||
1256 | if (text) { |
||
1257 | end = this.insert(range.start, text); |
||
1258 | } |
||
1259 | else { |
||
1260 | end = range.start; |
||
1261 | } |
||
1262 | |||
1263 | return end; |
||
1264 | }; |
||
1265 | this.applyDeltas = function(deltas) { |
||
1266 | for (var i=0; i<deltas.length; i++) { |
||
1267 | this.applyDelta(deltas[i]); |
||
1268 | } |
||
1269 | }; |
||
1270 | this.revertDeltas = function(deltas) { |
||
1271 | for (var i=deltas.length-1; i>=0; i--) { |
||
1272 | this.revertDelta(deltas[i]); |
||
1273 | } |
||
1274 | }; |
||
1275 | this.applyDelta = function(delta, doNotValidate) { |
||
1276 | var isInsert = delta.action == "insert"; |
||
1277 | if (isInsert ? delta.lines.length <= 1 && !delta.lines[0] |
||
1278 | : !Range.comparePoints(delta.start, delta.end)) { |
||
1279 | return; |
||
1280 | } |
||
1281 | |||
1282 | if (isInsert && delta.lines.length > 20000) |
||
1283 | this.$splitAndapplyLargeDelta(delta, 20000); |
||
1284 | applyDelta(this.$lines, delta, doNotValidate); |
||
1285 | this._signal("change", delta); |
||
1286 | }; |
||
1287 | |||
1288 | this.$splitAndapplyLargeDelta = function(delta, MAX) { |
||
1289 | var lines = delta.lines; |
||
1290 | var l = lines.length; |
||
1291 | var row = delta.start.row; |
||
1292 | var column = delta.start.column; |
||
1293 | var from = 0, to = 0; |
||
1294 | do { |
||
1295 | from = to; |
||
1296 | to += MAX - 1; |
||
1297 | var chunk = lines.slice(from, to); |
||
1298 | if (to > l) { |
||
1299 | delta.lines = chunk; |
||
1300 | delta.start.row = row + from; |
||
1301 | delta.start.column = column; |
||
1302 | break; |
||
1303 | } |
||
1304 | chunk.push(""); |
||
1305 | this.applyDelta({ |
||
1306 | start: this.pos(row + from, column), |
||
1307 | end: this.pos(row + to, column = 0), |
||
1308 | action: delta.action, |
||
1309 | lines: chunk |
||
1310 | }, true); |
||
1311 | } while(true); |
||
1312 | }; |
||
1313 | this.revertDelta = function(delta) { |
||
1314 | this.applyDelta({ |
||
1315 | start: this.clonePos(delta.start), |
||
1316 | end: this.clonePos(delta.end), |
||
1317 | action: (delta.action == "insert" ? "remove" : "insert"), |
||
1318 | lines: delta.lines.slice() |
||
1319 | }); |
||
1320 | }; |
||
1321 | this.indexToPosition = function(index, startRow) { |
||
1322 | var lines = this.$lines || this.getAllLines(); |
||
1323 | var newlineLength = this.getNewLineCharacter().length; |
||
1324 | for (var i = startRow || 0, l = lines.length; i < l; i++) { |
||
1325 | index -= lines[i].length + newlineLength; |
||
1326 | if (index < 0) |
||
1327 | return {row: i, column: index + lines[i].length + newlineLength}; |
||
1328 | } |
||
1329 | return {row: l-1, column: lines[l-1].length}; |
||
1330 | }; |
||
1331 | this.positionToIndex = function(pos, startRow) { |
||
1332 | var lines = this.$lines || this.getAllLines(); |
||
1333 | var newlineLength = this.getNewLineCharacter().length; |
||
1334 | var index = 0; |
||
1335 | var row = Math.min(pos.row, lines.length); |
||
1336 | for (var i = startRow || 0; i < row; ++i) |
||
1337 | index += lines[i].length + newlineLength; |
||
1338 | |||
1339 | return index + pos.column; |
||
1340 | }; |
||
1341 | |||
1342 | }).call(Document.prototype); |
||
1343 | |||
1344 | exports.Document = Document; |
||
1345 | }); |
||
1346 | |||
1347 | ace.define("ace/worker/mirror",["require","exports","module","ace/range","ace/document","ace/lib/lang"], function(require, exports, module) { |
||
1348 | "use strict"; |
||
1349 | |||
1350 | var Range = require("../range").Range; |
||
1351 | var Document = require("../document").Document; |
||
1352 | var lang = require("../lib/lang"); |
||
1353 | |||
1354 | var Mirror = exports.Mirror = function(sender) { |
||
1355 | this.sender = sender; |
||
1356 | var doc = this.doc = new Document(""); |
||
1357 | |||
1358 | var deferredUpdate = this.deferredUpdate = lang.delayedCall(this.onUpdate.bind(this)); |
||
1359 | |||
1360 | var _self = this; |
||
1361 | sender.on("change", function(e) { |
||
1362 | var data = e.data; |
||
1363 | if (data[0].start) { |
||
1364 | doc.applyDeltas(data); |
||
1365 | } else { |
||
1366 | for (var i = 0; i < data.length; i += 2) { |
||
1367 | if (Array.isArray(data[i+1])) { |
||
1368 | var d = {action: "insert", start: data[i], lines: data[i+1]}; |
||
1369 | } else { |
||
1370 | var d = {action: "remove", start: data[i], end: data[i+1]}; |
||
1371 | } |
||
1372 | doc.applyDelta(d, true); |
||
1373 | } |
||
1374 | } |
||
1375 | if (_self.$timeout) |
||
1376 | return deferredUpdate.schedule(_self.$timeout); |
||
1377 | _self.onUpdate(); |
||
1378 | }); |
||
1379 | }; |
||
1380 | |||
1381 | (function() { |
||
1382 | |||
1383 | this.$timeout = 500; |
||
1384 | |||
1385 | this.setTimeout = function(timeout) { |
||
1386 | this.$timeout = timeout; |
||
1387 | }; |
||
1388 | |||
1389 | this.setValue = function(value) { |
||
1390 | this.doc.setValue(value); |
||
1391 | this.deferredUpdate.schedule(this.$timeout); |
||
1392 | }; |
||
1393 | |||
1394 | this.getValue = function(callbackId) { |
||
1395 | this.sender.callback(this.doc.getValue(), callbackId); |
||
1396 | }; |
||
1397 | |||
1398 | this.onUpdate = function() { |
||
1399 | }; |
||
1400 | |||
1401 | this.isPending = function() { |
||
1402 | return this.deferredUpdate.isPending(); |
||
1403 | }; |
||
1404 | |||
1405 | }).call(Mirror.prototype); |
||
1406 | |||
1407 | }); |
||
1408 | |||
1409 | ace.define("ace/mode/html/saxparser",["require","exports","module"], function(require, exports, module) { |
||
1410 | module.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})({ |
||
1411 | 1:[function(_dereq_,module,exports){ |
||
1412 | function isScopeMarker(node) { |
||
1413 | if (node.namespaceURI === "http://www.w3.org/1999/xhtml") { |
||
1414 | return node.localName === "applet" |
||
1415 | || node.localName === "caption" |
||
1416 | || node.localName === "marquee" |
||
1417 | || node.localName === "object" |
||
1418 | || node.localName === "table" |
||
1419 | || node.localName === "td" |
||
1420 | || node.localName === "th"; |
||
1421 | } |
||
1422 | if (node.namespaceURI === "http://www.w3.org/1998/Math/MathML") { |
||
1423 | return node.localName === "mi" |
||
1424 | || node.localName === "mo" |
||
1425 | || node.localName === "mn" |
||
1426 | || node.localName === "ms" |
||
1427 | || node.localName === "mtext" |
||
1428 | || node.localName === "annotation-xml"; |
||
1429 | } |
||
1430 | if (node.namespaceURI === "http://www.w3.org/2000/svg") { |
||
1431 | return node.localName === "foreignObject" |
||
1432 | || node.localName === "desc" |
||
1433 | || node.localName === "title"; |
||
1434 | } |
||
1435 | } |
||
1436 | |||
1437 | function isListItemScopeMarker(node) { |
||
1438 | return isScopeMarker(node) |
||
1439 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'ol') |
||
1440 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'ul'); |
||
1441 | } |
||
1442 | |||
1443 | function isTableScopeMarker(node) { |
||
1444 | return (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'table') |
||
1445 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'html'); |
||
1446 | } |
||
1447 | |||
1448 | function isTableBodyScopeMarker(node) { |
||
1449 | return (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'tbody') |
||
1450 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'tfoot') |
||
1451 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'thead') |
||
1452 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'html'); |
||
1453 | } |
||
1454 | |||
1455 | function isTableRowScopeMarker(node) { |
||
1456 | return (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'tr') |
||
1457 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'html'); |
||
1458 | } |
||
1459 | |||
1460 | function isButtonScopeMarker(node) { |
||
1461 | return isScopeMarker(node) |
||
1462 | || (node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'button'); |
||
1463 | } |
||
1464 | |||
1465 | function isSelectScopeMarker(node) { |
||
1466 | return !(node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'optgroup') |
||
1467 | && !(node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.localName === 'option'); |
||
1468 | } |
||
1469 | function ElementStack() { |
||
1470 | this.elements = []; |
||
1471 | this.rootNode = null; |
||
1472 | this.headElement = null; |
||
1473 | this.bodyElement = null; |
||
1474 | } |
||
1475 | ElementStack.prototype._inScope = function(localName, isMarker) { |
||
1476 | for (var i = this.elements.length - 1; i >= 0; i--) { |
||
1477 | var node = this.elements[i]; |
||
1478 | if (node.localName === localName) |
||
1479 | return true; |
||
1480 | if (isMarker(node)) |
||
1481 | return false; |
||
1482 | } |
||
1483 | }; |
||
1484 | ElementStack.prototype.push = function(item) { |
||
1485 | this.elements.push(item); |
||
1486 | }; |
||
1487 | ElementStack.prototype.pushHtmlElement = function(item) { |
||
1488 | this.rootNode = item.node; |
||
1489 | this.push(item); |
||
1490 | }; |
||
1491 | ElementStack.prototype.pushHeadElement = function(item) { |
||
1492 | this.headElement = item.node; |
||
1493 | this.push(item); |
||
1494 | }; |
||
1495 | ElementStack.prototype.pushBodyElement = function(item) { |
||
1496 | this.bodyElement = item.node; |
||
1497 | this.push(item); |
||
1498 | }; |
||
1499 | ElementStack.prototype.pop = function() { |
||
1500 | return this.elements.pop(); |
||
1501 | }; |
||
1502 | ElementStack.prototype.remove = function(item) { |
||
1503 | this.elements.splice(this.elements.indexOf(item), 1); |
||
1504 | }; |
||
1505 | ElementStack.prototype.popUntilPopped = function(localName) { |
||
1506 | var element; |
||
1507 | do { |
||
1508 | element = this.pop(); |
||
1509 | } while (element.localName != localName); |
||
1510 | }; |
||
1511 | |||
1512 | ElementStack.prototype.popUntilTableScopeMarker = function() { |
||
1513 | while (!isTableScopeMarker(this.top)) |
||
1514 | this.pop(); |
||
1515 | }; |
||
1516 | |||
1517 | ElementStack.prototype.popUntilTableBodyScopeMarker = function() { |
||
1518 | while (!isTableBodyScopeMarker(this.top)) |
||
1519 | this.pop(); |
||
1520 | }; |
||
1521 | |||
1522 | ElementStack.prototype.popUntilTableRowScopeMarker = function() { |
||
1523 | while (!isTableRowScopeMarker(this.top)) |
||
1524 | this.pop(); |
||
1525 | }; |
||
1526 | ElementStack.prototype.item = function(index) { |
||
1527 | return this.elements[index]; |
||
1528 | }; |
||
1529 | ElementStack.prototype.contains = function(element) { |
||
1530 | return this.elements.indexOf(element) !== -1; |
||
1531 | }; |
||
1532 | ElementStack.prototype.inScope = function(localName) { |
||
1533 | return this._inScope(localName, isScopeMarker); |
||
1534 | }; |
||
1535 | ElementStack.prototype.inListItemScope = function(localName) { |
||
1536 | return this._inScope(localName, isListItemScopeMarker); |
||
1537 | }; |
||
1538 | ElementStack.prototype.inTableScope = function(localName) { |
||
1539 | return this._inScope(localName, isTableScopeMarker); |
||
1540 | }; |
||
1541 | ElementStack.prototype.inButtonScope = function(localName) { |
||
1542 | return this._inScope(localName, isButtonScopeMarker); |
||
1543 | }; |
||
1544 | ElementStack.prototype.inSelectScope = function(localName) { |
||
1545 | return this._inScope(localName, isSelectScopeMarker); |
||
1546 | }; |
||
1547 | ElementStack.prototype.hasNumberedHeaderElementInScope = function() { |
||
1548 | for (var i = this.elements.length - 1; i >= 0; i--) { |
||
1549 | var node = this.elements[i]; |
||
1550 | if (node.isNumberedHeader()) |
||
1551 | return true; |
||
1552 | if (isScopeMarker(node)) |
||
1553 | return false; |
||
1554 | } |
||
1555 | }; |
||
1556 | ElementStack.prototype.furthestBlockForFormattingElement = function(element) { |
||
1557 | var furthestBlock = null; |
||
1558 | for (var i = this.elements.length - 1; i >= 0; i--) { |
||
1559 | var node = this.elements[i]; |
||
1560 | if (node.node === element) |
||
1561 | break; |
||
1562 | if (node.isSpecial()) |
||
1563 | furthestBlock = node; |
||
1564 | } |
||
1565 | return furthestBlock; |
||
1566 | }; |
||
1567 | ElementStack.prototype.findIndex = function(localName) { |
||
1568 | for (var i = this.elements.length - 1; i >= 0; i--) { |
||
1569 | if (this.elements[i].localName == localName) |
||
1570 | return i; |
||
1571 | } |
||
1572 | return -1; |
||
1573 | }; |
||
1574 | |||
1575 | ElementStack.prototype.remove_openElements_until = function(callback) { |
||
1576 | var finished = false; |
||
1577 | var element; |
||
1578 | while (!finished) { |
||
1579 | element = this.elements.pop(); |
||
1580 | finished = callback(element); |
||
1581 | } |
||
1582 | return element; |
||
1583 | }; |
||
1584 | |||
1585 | Object.defineProperty(ElementStack.prototype, 'top', { |
||
1586 | get: function() { |
||
1587 | return this.elements[this.elements.length - 1]; |
||
1588 | } |
||
1589 | }); |
||
1590 | |||
1591 | Object.defineProperty(ElementStack.prototype, 'length', { |
||
1592 | get: function() { |
||
1593 | return this.elements.length; |
||
1594 | } |
||
1595 | }); |
||
1596 | |||
1597 | exports.ElementStack = ElementStack; |
||
1598 | |||
1599 | }, |
||
1600 | {}], |
||
1601 | 2:[function(_dereq_,module,exports){ |
||
1602 | var entities = _dereq_('html5-entities'); |
||
1603 | var InputStream = _dereq_('./InputStream').InputStream; |
||
1604 | |||
1605 | var namedEntityPrefixes = {}; |
||
1606 | Object.keys(entities).forEach(function (entityKey) { |
||
1607 | for (var i = 0; i < entityKey.length; i++) { |
||
1608 | namedEntityPrefixes[entityKey.substring(0, i + 1)] = true; |
||
1609 | } |
||
1610 | }); |
||
1611 | |||
1612 | function isAlphaNumeric(c) { |
||
1613 | return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); |
||
1614 | } |
||
1615 | |||
1616 | function isHexDigit(c) { |
||
1617 | return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); |
||
1618 | } |
||
1619 | |||
1620 | function isDecimalDigit(c) { |
||
1621 | return (c >= '0' && c <= '9'); |
||
1622 | } |
||
1623 | |||
1624 | var EntityParser = {}; |
||
1625 | |||
1626 | EntityParser.consumeEntity = function(buffer, tokenizer, additionalAllowedCharacter) { |
||
1627 | var decodedCharacter = ''; |
||
1628 | var consumedCharacters = ''; |
||
1629 | var ch = buffer.char(); |
||
1630 | if (ch === InputStream.EOF) |
||
1631 | return false; |
||
1632 | consumedCharacters += ch; |
||
1633 | if (ch == '\t' || ch == '\n' || ch == '\v' || ch == ' ' || ch == '<' || ch == '&') { |
||
1634 | buffer.unget(consumedCharacters); |
||
1635 | return false; |
||
1636 | } |
||
1637 | if (additionalAllowedCharacter === ch) { |
||
1638 | buffer.unget(consumedCharacters); |
||
1639 | return false; |
||
1640 | } |
||
1641 | if (ch == '#') { |
||
1642 | ch = buffer.shift(1); |
||
1643 | if (ch === InputStream.EOF) { |
||
1644 | tokenizer._parseError("expected-numeric-entity-but-got-eof"); |
||
1645 | buffer.unget(consumedCharacters); |
||
1646 | return false; |
||
1647 | } |
||
1648 | consumedCharacters += ch; |
||
1649 | var radix = 10; |
||
1650 | var isDigit = isDecimalDigit; |
||
1651 | if (ch == 'x' || ch == 'X') { |
||
1652 | radix = 16; |
||
1653 | isDigit = isHexDigit; |
||
1654 | ch = buffer.shift(1); |
||
1655 | if (ch === InputStream.EOF) { |
||
1656 | tokenizer._parseError("expected-numeric-entity-but-got-eof"); |
||
1657 | buffer.unget(consumedCharacters); |
||
1658 | return false; |
||
1659 | } |
||
1660 | consumedCharacters += ch; |
||
1661 | } |
||
1662 | if (isDigit(ch)) { |
||
1663 | var code = ''; |
||
1664 | while (ch !== InputStream.EOF && isDigit(ch)) { |
||
1665 | code += ch; |
||
1666 | ch = buffer.char(); |
||
1667 | } |
||
1668 | code = parseInt(code, radix); |
||
1669 | var replacement = this.replaceEntityNumbers(code); |
||
1670 | if (replacement) { |
||
1671 | tokenizer._parseError("invalid-numeric-entity-replaced"); |
||
1672 | code = replacement; |
||
1673 | } |
||
1674 | if (code > 0xFFFF && code <= 0x10FFFF) { |
||
1675 | code -= 0x10000; |
||
1676 | var first = ((0xffc00 & code) >> 10) + 0xD800; |
||
1677 | var second = (0x3ff & code) + 0xDC00; |
||
1678 | decodedCharacter = String.fromCharCode(first, second); |
||
1679 | } else |
||
1680 | decodedCharacter = String.fromCharCode(code); |
||
1681 | if (ch !== ';') { |
||
1682 | tokenizer._parseError("numeric-entity-without-semicolon"); |
||
1683 | buffer.unget(ch); |
||
1684 | } |
||
1685 | return decodedCharacter; |
||
1686 | } |
||
1687 | buffer.unget(consumedCharacters); |
||
1688 | tokenizer._parseError("expected-numeric-entity"); |
||
1689 | return false; |
||
1690 | } |
||
1691 | if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) { |
||
1692 | var mostRecentMatch = ''; |
||
1693 | while (namedEntityPrefixes[consumedCharacters]) { |
||
1694 | if (entities[consumedCharacters]) { |
||
1695 | mostRecentMatch = consumedCharacters; |
||
1696 | } |
||
1697 | if (ch == ';') |
||
1698 | break; |
||
1699 | ch = buffer.char(); |
||
1700 | if (ch === InputStream.EOF) |
||
1701 | break; |
||
1702 | consumedCharacters += ch; |
||
1703 | } |
||
1704 | if (!mostRecentMatch) { |
||
1705 | tokenizer._parseError("expected-named-entity"); |
||
1706 | buffer.unget(consumedCharacters); |
||
1707 | return false; |
||
1708 | } |
||
1709 | decodedCharacter = entities[mostRecentMatch]; |
||
1710 | if (ch === ';' || !additionalAllowedCharacter || !(isAlphaNumeric(ch) || ch === '=')) { |
||
1711 | if (consumedCharacters.length > mostRecentMatch.length) { |
||
1712 | buffer.unget(consumedCharacters.substring(mostRecentMatch.length)); |
||
1713 | } |
||
1714 | if (ch !== ';') { |
||
1715 | tokenizer._parseError("named-entity-without-semicolon"); |
||
1716 | } |
||
1717 | return decodedCharacter; |
||
1718 | } |
||
1719 | buffer.unget(consumedCharacters); |
||
1720 | return false; |
||
1721 | } |
||
1722 | }; |
||
1723 | |||
1724 | EntityParser.replaceEntityNumbers = function(c) { |
||
1725 | switch(c) { |
||
1726 | case 0x00: return 0xFFFD; // REPLACEMENT CHARACTER |
||
1727 | case 0x13: return 0x0010; // Carriage return |
||
1728 | case 0x80: return 0x20AC; // EURO SIGN |
||
1729 | case 0x81: return 0x0081; // <control> |
||
1730 | case 0x82: return 0x201A; // SINGLE LOW-9 QUOTATION MARK |
||
1731 | case 0x83: return 0x0192; // LATIN SMALL LETTER F WITH HOOK |
||
1732 | case 0x84: return 0x201E; // DOUBLE LOW-9 QUOTATION MARK |
||
1733 | case 0x85: return 0x2026; // HORIZONTAL ELLIPSIS |
||
1734 | case 0x86: return 0x2020; // DAGGER |
||
1735 | case 0x87: return 0x2021; // DOUBLE DAGGER |
||
1736 | case 0x88: return 0x02C6; // MODIFIER LETTER CIRCUMFLEX ACCENT |
||
1737 | case 0x89: return 0x2030; // PER MILLE SIGN |
||
1738 | case 0x8A: return 0x0160; // LATIN CAPITAL LETTER S WITH CARON |
||
1739 | case 0x8B: return 0x2039; // SINGLE LEFT-POINTING ANGLE QUOTATION MARK |
||
1740 | case 0x8C: return 0x0152; // LATIN CAPITAL LIGATURE OE |
||
1741 | case 0x8D: return 0x008D; // <control> |
||
1742 | case 0x8E: return 0x017D; // LATIN CAPITAL LETTER Z WITH CARON |
||
1743 | case 0x8F: return 0x008F; // <control> |
||
1744 | case 0x90: return 0x0090; // <control> |
||
1745 | case 0x91: return 0x2018; // LEFT SINGLE QUOTATION MARK |
||
1746 | case 0x92: return 0x2019; // RIGHT SINGLE QUOTATION MARK |
||
1747 | case 0x93: return 0x201C; // LEFT DOUBLE QUOTATION MARK |
||
1748 | case 0x94: return 0x201D; // RIGHT DOUBLE QUOTATION MARK |
||
1749 | case 0x95: return 0x2022; // BULLET |
||
1750 | case 0x96: return 0x2013; // EN DASH |
||
1751 | case 0x97: return 0x2014; // EM DASH |
||
1752 | case 0x98: return 0x02DC; // SMALL TILDE |
||
1753 | case 0x99: return 0x2122; // TRADE MARK SIGN |
||
1754 | case 0x9A: return 0x0161; // LATIN SMALL LETTER S WITH CARON |
||
1755 | case 0x9B: return 0x203A; // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK |
||
1756 | case 0x9C: return 0x0153; // LATIN SMALL LIGATURE OE |
||
1757 | case 0x9D: return 0x009D; // <control> |
||
1758 | case 0x9E: return 0x017E; // LATIN SMALL LETTER Z WITH CARON |
||
1759 | case 0x9F: return 0x0178; // LATIN CAPITAL LETTER Y WITH DIAERESIS |
||
1760 | default: |
||
1761 | if ((c >= 0xD800 && c <= 0xDFFF) || c > 0x10FFFF) { |
||
1762 | return 0xFFFD; |
||
1763 | } else if ((c >= 0x0001 && c <= 0x0008) || (c >= 0x000E && c <= 0x001F) || |
||
1764 | (c >= 0x007F && c <= 0x009F) || (c >= 0xFDD0 && c <= 0xFDEF) || |
||
1765 | c == 0x000B || c == 0xFFFE || c == 0x1FFFE || c == 0x2FFFFE || |
||
1766 | c == 0x2FFFF || c == 0x3FFFE || c == 0x3FFFF || c == 0x4FFFE || |
||
1767 | c == 0x4FFFF || c == 0x5FFFE || c == 0x5FFFF || c == 0x6FFFE || |
||
1768 | c == 0x6FFFF || c == 0x7FFFE || c == 0x7FFFF || c == 0x8FFFE || |
||
1769 | c == 0x8FFFF || c == 0x9FFFE || c == 0x9FFFF || c == 0xAFFFE || |
||
1770 | c == 0xAFFFF || c == 0xBFFFE || c == 0xBFFFF || c == 0xCFFFE || |
||
1771 | c == 0xCFFFF || c == 0xDFFFE || c == 0xDFFFF || c == 0xEFFFE || |
||
1772 | c == 0xEFFFF || c == 0xFFFFE || c == 0xFFFFF || c == 0x10FFFE || |
||
1773 | c == 0x10FFFF) { |
||
1774 | return c; |
||
1775 | } |
||
1776 | } |
||
1777 | }; |
||
1778 | |||
1779 | exports.EntityParser = EntityParser; |
||
1780 | |||
1781 | }, |
||
1782 | {"./InputStream":3,"html5-entities":12}], |
||
1783 | 3:[function(_dereq_,module,exports){ |
||
1784 | function InputStream() { |
||
1785 | this.data = ''; |
||
1786 | this.start = 0; |
||
1787 | this.committed = 0; |
||
1788 | this.eof = false; |
||
1789 | this.lastLocation = {line: 0, column: 0}; |
||
1790 | } |
||
1791 | |||
1792 | InputStream.EOF = -1; |
||
1793 | |||
1794 | InputStream.DRAIN = -2; |
||
1795 | |||
1796 | InputStream.prototype = { |
||
1797 | slice: function() { |
||
1798 | if(this.start >= this.data.length) { |
||
1799 | if(!this.eof) throw InputStream.DRAIN; |
||
1800 | return InputStream.EOF; |
||
1801 | } |
||
1802 | return this.data.slice(this.start, this.data.length); |
||
1803 | }, |
||
1804 | char: function() { |
||
1805 | if(!this.eof && this.start >= this.data.length - 1) throw InputStream.DRAIN; |
||
1806 | if(this.start >= this.data.length) { |
||
1807 | return InputStream.EOF; |
||
1808 | } |
||
1809 | var ch = this.data[this.start++]; |
||
1810 | if (ch === '\r') |
||
1811 | ch = '\n'; |
||
1812 | return ch; |
||
1813 | }, |
||
1814 | advance: function(amount) { |
||
1815 | this.start += amount; |
||
1816 | if(this.start >= this.data.length) { |
||
1817 | if(!this.eof) throw InputStream.DRAIN; |
||
1818 | return InputStream.EOF; |
||
1819 | } else { |
||
1820 | if(this.committed > this.data.length / 2) { |
||
1821 | this.lastLocation = this.location(); |
||
1822 | this.data = this.data.slice(this.committed); |
||
1823 | this.start = this.start - this.committed; |
||
1824 | this.committed = 0; |
||
1825 | } |
||
1826 | } |
||
1827 | }, |
||
1828 | matchWhile: function(re) { |
||
1829 | if(this.eof && this.start >= this.data.length ) return ''; |
||
1830 | var r = new RegExp("^"+re+"+"); |
||
1831 | var m = r.exec(this.slice()); |
||
1832 | if(m) { |
||
1833 | if(!this.eof && m[0].length == this.data.length - this.start) throw InputStream.DRAIN; |
||
1834 | this.advance(m[0].length); |
||
1835 | return m[0]; |
||
1836 | } else { |
||
1837 | return ''; |
||
1838 | } |
||
1839 | }, |
||
1840 | matchUntil: function(re) { |
||
1841 | var m, s; |
||
1842 | s = this.slice(); |
||
1843 | if(s === InputStream.EOF) { |
||
1844 | return ''; |
||
1845 | } else if(m = new RegExp(re + (this.eof ? "|$" : "")).exec(s)) { |
||
1846 | var t = this.data.slice(this.start, this.start + m.index); |
||
1847 | this.advance(m.index); |
||
1848 | return t.replace(/\r/g, '\n').replace(/\n{2,}/g, '\n'); |
||
1849 | } else { |
||
1850 | throw InputStream.DRAIN; |
||
1851 | } |
||
1852 | }, |
||
1853 | append: function(data) { |
||
1854 | this.data += data; |
||
1855 | }, |
||
1856 | shift: function(n) { |
||
1857 | if(!this.eof && this.start + n >= this.data.length) throw InputStream.DRAIN; |
||
1858 | if(this.eof && this.start >= this.data.length) return InputStream.EOF; |
||
1859 | var d = this.data.slice(this.start, this.start + n).toString(); |
||
1860 | this.advance(Math.min(n, this.data.length - this.start)); |
||
1861 | return d; |
||
1862 | }, |
||
1863 | peek: function(n) { |
||
1864 | if(!this.eof && this.start + n >= this.data.length) throw InputStream.DRAIN; |
||
1865 | if(this.eof && this.start >= this.data.length) return InputStream.EOF; |
||
1866 | return this.data.slice(this.start, Math.min(this.start + n, this.data.length)).toString(); |
||
1867 | }, |
||
1868 | length: function() { |
||
1869 | return this.data.length - this.start - 1; |
||
1870 | }, |
||
1871 | unget: function(d) { |
||
1872 | if(d === InputStream.EOF) return; |
||
1873 | this.start -= (d.length); |
||
1874 | }, |
||
1875 | undo: function() { |
||
1876 | this.start = this.committed; |
||
1877 | }, |
||
1878 | commit: function() { |
||
1879 | this.committed = this.start; |
||
1880 | }, |
||
1881 | location: function() { |
||
1882 | var lastLine = this.lastLocation.line; |
||
1883 | var lastColumn = this.lastLocation.column; |
||
1884 | var read = this.data.slice(0, this.committed); |
||
1885 | var newlines = read.match(/\n/g); |
||
1886 | var line = newlines ? lastLine + newlines.length : lastLine; |
||
1887 | var column = newlines ? read.length - read.lastIndexOf('\n') - 1 : lastColumn + read.length; |
||
1888 | return {line: line, column: column}; |
||
1889 | } |
||
1890 | }; |
||
1891 | |||
1892 | exports.InputStream = InputStream; |
||
1893 | |||
1894 | }, |
||
1895 | {}], |
||
1896 | 4:[function(_dereq_,module,exports){ |
||
1897 | var SpecialElements = { |
||
1898 | "http://www.w3.org/1999/xhtml": [ |
||
1899 | 'address', |
||
1900 | 'applet', |
||
1901 | 'area', |
||
1902 | 'article', |
||
1903 | 'aside', |
||
1904 | 'base', |
||
1905 | 'basefont', |
||
1906 | 'bgsound', |
||
1907 | 'blockquote', |
||
1908 | 'body', |
||
1909 | 'br', |
||
1910 | 'button', |
||
1911 | 'caption', |
||
1912 | 'center', |
||
1913 | 'col', |
||
1914 | 'colgroup', |
||
1915 | 'dd', |
||
1916 | 'details', |
||
1917 | 'dir', |
||
1918 | 'div', |
||
1919 | 'dl', |
||
1920 | 'dt', |
||
1921 | 'embed', |
||
1922 | 'fieldset', |
||
1923 | 'figcaption', |
||
1924 | 'figure', |
||
1925 | 'footer', |
||
1926 | 'form', |
||
1927 | 'frame', |
||
1928 | 'frameset', |
||
1929 | 'h1', |
||
1930 | 'h2', |
||
1931 | 'h3', |
||
1932 | 'h4', |
||
1933 | 'h5', |
||
1934 | 'h6', |
||
1935 | 'head', |
||
1936 | 'header', |
||
1937 | 'hgroup', |
||
1938 | 'hr', |
||
1939 | 'html', |
||
1940 | 'iframe', |
||
1941 | 'img', |
||
1942 | 'input', |
||
1943 | 'isindex', |
||
1944 | 'li', |
||
1945 | 'link', |
||
1946 | 'listing', |
||
1947 | 'main', |
||
1948 | 'marquee', |
||
1949 | 'menu', |
||
1950 | 'menuitem', |
||
1951 | 'meta', |
||
1952 | 'nav', |
||
1953 | 'noembed', |
||
1954 | 'noframes', |
||
1955 | 'noscript', |
||
1956 | 'object', |
||
1957 | 'ol', |
||
1958 | 'p', |
||
1959 | 'param', |
||
1960 | 'plaintext', |
||
1961 | 'pre', |
||
1962 | 'script', |
||
1963 | 'section', |
||
1964 | 'select', |
||
1965 | 'source', |
||
1966 | 'style', |
||
1967 | 'summary', |
||
1968 | 'table', |
||
1969 | 'tbody', |
||
1970 | 'td', |
||
1971 | 'textarea', |
||
1972 | 'tfoot', |
||
1973 | 'th', |
||
1974 | 'thead', |
||
1975 | 'title', |
||
1976 | 'tr', |
||
1977 | 'track', |
||
1978 | 'ul', |
||
1979 | 'wbr', |
||
1980 | 'xmp' |
||
1981 | ], |
||
1982 | "http://www.w3.org/1998/Math/MathML": [ |
||
1983 | 'mi', |
||
1984 | 'mo', |
||
1985 | 'mn', |
||
1986 | 'ms', |
||
1987 | 'mtext', |
||
1988 | 'annotation-xml' |
||
1989 | ], |
||
1990 | "http://www.w3.org/2000/svg": [ |
||
1991 | 'foreignObject', |
||
1992 | 'desc', |
||
1993 | 'title' |
||
1994 | ] |
||
1995 | }; |
||
1996 | |||
1997 | |||
1998 | function StackItem(namespaceURI, localName, attributes, node) { |
||
1999 | this.localName = localName; |
||
2000 | this.namespaceURI = namespaceURI; |
||
2001 | this.attributes = attributes; |
||
2002 | this.node = node; |
||
2003 | } |
||
2004 | StackItem.prototype.isSpecial = function() { |
||
2005 | return this.namespaceURI in SpecialElements && |
||
2006 | SpecialElements[this.namespaceURI].indexOf(this.localName) > -1; |
||
2007 | }; |
||
2008 | |||
2009 | StackItem.prototype.isFosterParenting = function() { |
||
2010 | if (this.namespaceURI === "http://www.w3.org/1999/xhtml") { |
||
2011 | return this.localName === 'table' || |
||
2012 | this.localName === 'tbody' || |
||
2013 | this.localName === 'tfoot' || |
||
2014 | this.localName === 'thead' || |
||
2015 | this.localName === 'tr'; |
||
2016 | } |
||
2017 | return false; |
||
2018 | }; |
||
2019 | |||
2020 | StackItem.prototype.isNumberedHeader = function() { |
||
2021 | if (this.namespaceURI === "http://www.w3.org/1999/xhtml") { |
||
2022 | return this.localName === 'h1' || |
||
2023 | this.localName === 'h2' || |
||
2024 | this.localName === 'h3' || |
||
2025 | this.localName === 'h4' || |
||
2026 | this.localName === 'h5' || |
||
2027 | this.localName === 'h6'; |
||
2028 | } |
||
2029 | return false; |
||
2030 | }; |
||
2031 | |||
2032 | StackItem.prototype.isForeign = function() { |
||
2033 | return this.namespaceURI != "http://www.w3.org/1999/xhtml"; |
||
2034 | }; |
||
2035 | |||
2036 | function getAttribute(item, name) { |
||
2037 | for (var i = 0; i < item.attributes.length; i++) { |
||
2038 | if (item.attributes[i].nodeName == name) |
||
2039 | return item.attributes[i].nodeValue; |
||
2040 | } |
||
2041 | return null; |
||
2042 | } |
||
2043 | |||
2044 | StackItem.prototype.isHtmlIntegrationPoint = function() { |
||
2045 | if (this.namespaceURI === "http://www.w3.org/1998/Math/MathML") { |
||
2046 | if (this.localName !== "annotation-xml") |
||
2047 | return false; |
||
2048 | var encoding = getAttribute(this, 'encoding'); |
||
2049 | if (!encoding) |
||
2050 | return false; |
||
2051 | encoding = encoding.toLowerCase(); |
||
2052 | return encoding === "text/html" || encoding === "application/xhtml+xml"; |
||
2053 | } |
||
2054 | if (this.namespaceURI === "http://www.w3.org/2000/svg") { |
||
2055 | return this.localName === "foreignObject" |
||
2056 | || this.localName === "desc" |
||
2057 | || this.localName === "title"; |
||
2058 | } |
||
2059 | return false; |
||
2060 | }; |
||
2061 | |||
2062 | StackItem.prototype.isMathMLTextIntegrationPoint = function() { |
||
2063 | if (this.namespaceURI === "http://www.w3.org/1998/Math/MathML") { |
||
2064 | return this.localName === "mi" |
||
2065 | || this.localName === "mo" |
||
2066 | || this.localName === "mn" |
||
2067 | || this.localName === "ms" |
||
2068 | || this.localName === "mtext"; |
||
2069 | } |
||
2070 | return false; |
||
2071 | }; |
||
2072 | |||
2073 | exports.StackItem = StackItem; |
||
2074 | |||
2075 | }, |
||
2076 | {}], |
||
2077 | 5:[function(_dereq_,module,exports){ |
||
2078 | var InputStream = _dereq_('./InputStream').InputStream; |
||
2079 | var EntityParser = _dereq_('./EntityParser').EntityParser; |
||
2080 | |||
2081 | function isWhitespace(c){ |
||
2082 | return c === " " || c === "\n" || c === "\t" || c === "\r" || c === "\f"; |
||
2083 | } |
||
2084 | |||
2085 | function isAlpha(c) { |
||
2086 | return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); |
||
2087 | } |
||
2088 | function Tokenizer(tokenHandler) { |
||
2089 | this._tokenHandler = tokenHandler; |
||
2090 | this._state = Tokenizer.DATA; |
||
2091 | this._inputStream = new InputStream(); |
||
2092 | this._currentToken = null; |
||
2093 | this._temporaryBuffer = ''; |
||
2094 | this._additionalAllowedCharacter = ''; |
||
2095 | } |
||
2096 | |||
2097 | Tokenizer.prototype._parseError = function(code, args) { |
||
2098 | this._tokenHandler.parseError(code, args); |
||
2099 | }; |
||
2100 | |||
2101 | Tokenizer.prototype._emitToken = function(token) { |
||
2102 | if (token.type === 'StartTag') { |
||
2103 | for (var i = 1; i < token.data.length; i++) { |
||
2104 | if (!token.data[i].nodeName) |
||
2105 | token.data.splice(i--, 1); |
||
2106 | } |
||
2107 | } else if (token.type === 'EndTag') { |
||
2108 | if (token.selfClosing) { |
||
2109 | this._parseError('self-closing-flag-on-end-tag'); |
||
2110 | } |
||
2111 | if (token.data.length !== 0) { |
||
2112 | this._parseError('attributes-in-end-tag'); |
||
2113 | } |
||
2114 | } |
||
2115 | this._tokenHandler.processToken(token); |
||
2116 | if (token.type === 'StartTag' && token.selfClosing && !this._tokenHandler.isSelfClosingFlagAcknowledged()) { |
||
2117 | this._parseError('non-void-element-with-trailing-solidus', {name: token.name}); |
||
2118 | } |
||
2119 | }; |
||
2120 | |||
2121 | Tokenizer.prototype._emitCurrentToken = function() { |
||
2122 | this._state = Tokenizer.DATA; |
||
2123 | this._emitToken(this._currentToken); |
||
2124 | }; |
||
2125 | |||
2126 | Tokenizer.prototype._currentAttribute = function() { |
||
2127 | return this._currentToken.data[this._currentToken.data.length - 1]; |
||
2128 | }; |
||
2129 | |||
2130 | Tokenizer.prototype.setState = function(state) { |
||
2131 | this._state = state; |
||
2132 | }; |
||
2133 | |||
2134 | Tokenizer.prototype.tokenize = function(source) { |
||
2135 | Tokenizer.DATA = data_state; |
||
2136 | Tokenizer.RCDATA = rcdata_state; |
||
2137 | Tokenizer.RAWTEXT = rawtext_state; |
||
2138 | Tokenizer.SCRIPT_DATA = script_data_state; |
||
2139 | Tokenizer.PLAINTEXT = plaintext_state; |
||
2140 | |||
2141 | |||
2142 | this._state = Tokenizer.DATA; |
||
2143 | |||
2144 | this._inputStream.append(source); |
||
2145 | |||
2146 | this._tokenHandler.startTokenization(this); |
||
2147 | |||
2148 | this._inputStream.eof = true; |
||
2149 | |||
2150 | var tokenizer = this; |
||
2151 | |||
2152 | while (this._state.call(this, this._inputStream)); |
||
2153 | |||
2154 | |||
2155 | function data_state(buffer) { |
||
2156 | var data = buffer.char(); |
||
2157 | if (data === InputStream.EOF) { |
||
2158 | tokenizer._emitToken({type: 'EOF', data: null}); |
||
2159 | return false; |
||
2160 | } else if (data === '&') { |
||
2161 | tokenizer.setState(character_reference_in_data_state); |
||
2162 | } else if (data === '<') { |
||
2163 | tokenizer.setState(tag_open_state); |
||
2164 | } else if (data === '\u0000') { |
||
2165 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2166 | buffer.commit(); |
||
2167 | } else { |
||
2168 | var chars = buffer.matchUntil("&|<|\u0000"); |
||
2169 | tokenizer._emitToken({type: 'Characters', data: data + chars}); |
||
2170 | buffer.commit(); |
||
2171 | } |
||
2172 | return true; |
||
2173 | } |
||
2174 | |||
2175 | function character_reference_in_data_state(buffer) { |
||
2176 | var character = EntityParser.consumeEntity(buffer, tokenizer); |
||
2177 | tokenizer.setState(data_state); |
||
2178 | tokenizer._emitToken({type: 'Characters', data: character || '&'}); |
||
2179 | return true; |
||
2180 | } |
||
2181 | |||
2182 | function rcdata_state(buffer) { |
||
2183 | var data = buffer.char(); |
||
2184 | if (data === InputStream.EOF) { |
||
2185 | tokenizer._emitToken({type: 'EOF', data: null}); |
||
2186 | return false; |
||
2187 | } else if (data === '&') { |
||
2188 | tokenizer.setState(character_reference_in_rcdata_state); |
||
2189 | } else if (data === '<') { |
||
2190 | tokenizer.setState(rcdata_less_than_sign_state); |
||
2191 | } else if (data === "\u0000") { |
||
2192 | tokenizer._parseError("invalid-codepoint"); |
||
2193 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2194 | buffer.commit(); |
||
2195 | } else { |
||
2196 | var chars = buffer.matchUntil("&|<|\u0000"); |
||
2197 | tokenizer._emitToken({type: 'Characters', data: data + chars}); |
||
2198 | buffer.commit(); |
||
2199 | } |
||
2200 | return true; |
||
2201 | } |
||
2202 | |||
2203 | function character_reference_in_rcdata_state(buffer) { |
||
2204 | var character = EntityParser.consumeEntity(buffer, tokenizer); |
||
2205 | tokenizer.setState(rcdata_state); |
||
2206 | tokenizer._emitToken({type: 'Characters', data: character || '&'}); |
||
2207 | return true; |
||
2208 | } |
||
2209 | |||
2210 | function rawtext_state(buffer) { |
||
2211 | var data = buffer.char(); |
||
2212 | if (data === InputStream.EOF) { |
||
2213 | tokenizer._emitToken({type: 'EOF', data: null}); |
||
2214 | return false; |
||
2215 | } else if (data === '<') { |
||
2216 | tokenizer.setState(rawtext_less_than_sign_state); |
||
2217 | } else if (data === "\u0000") { |
||
2218 | tokenizer._parseError("invalid-codepoint"); |
||
2219 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2220 | buffer.commit(); |
||
2221 | } else { |
||
2222 | var chars = buffer.matchUntil("<|\u0000"); |
||
2223 | tokenizer._emitToken({type: 'Characters', data: data + chars}); |
||
2224 | } |
||
2225 | return true; |
||
2226 | } |
||
2227 | |||
2228 | function plaintext_state(buffer) { |
||
2229 | var data = buffer.char(); |
||
2230 | if (data === InputStream.EOF) { |
||
2231 | tokenizer._emitToken({type: 'EOF', data: null}); |
||
2232 | return false; |
||
2233 | } else if (data === "\u0000") { |
||
2234 | tokenizer._parseError("invalid-codepoint"); |
||
2235 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2236 | buffer.commit(); |
||
2237 | } else { |
||
2238 | var chars = buffer.matchUntil("\u0000"); |
||
2239 | tokenizer._emitToken({type: 'Characters', data: data + chars}); |
||
2240 | } |
||
2241 | return true; |
||
2242 | } |
||
2243 | |||
2244 | |||
2245 | function script_data_state(buffer) { |
||
2246 | var data = buffer.char(); |
||
2247 | if (data === InputStream.EOF) { |
||
2248 | tokenizer._emitToken({type: 'EOF', data: null}); |
||
2249 | return false; |
||
2250 | } else if (data === '<') { |
||
2251 | tokenizer.setState(script_data_less_than_sign_state); |
||
2252 | } else if (data === '\u0000') { |
||
2253 | tokenizer._parseError("invalid-codepoint"); |
||
2254 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2255 | buffer.commit(); |
||
2256 | } else { |
||
2257 | var chars = buffer.matchUntil("<|\u0000"); |
||
2258 | tokenizer._emitToken({type: 'Characters', data: data + chars}); |
||
2259 | } |
||
2260 | return true; |
||
2261 | } |
||
2262 | |||
2263 | function rcdata_less_than_sign_state(buffer) { |
||
2264 | var data = buffer.char(); |
||
2265 | if (data === "/") { |
||
2266 | this._temporaryBuffer = ''; |
||
2267 | tokenizer.setState(rcdata_end_tag_open_state); |
||
2268 | } else { |
||
2269 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2270 | buffer.unget(data); |
||
2271 | tokenizer.setState(rcdata_state); |
||
2272 | } |
||
2273 | return true; |
||
2274 | } |
||
2275 | |||
2276 | function rcdata_end_tag_open_state(buffer) { |
||
2277 | var data = buffer.char(); |
||
2278 | if (isAlpha(data)) { |
||
2279 | this._temporaryBuffer += data; |
||
2280 | tokenizer.setState(rcdata_end_tag_name_state); |
||
2281 | } else { |
||
2282 | tokenizer._emitToken({type: 'Characters', data: '</'}); |
||
2283 | buffer.unget(data); |
||
2284 | tokenizer.setState(rcdata_state); |
||
2285 | } |
||
2286 | return true; |
||
2287 | } |
||
2288 | |||
2289 | function rcdata_end_tag_name_state(buffer) { |
||
2290 | var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase()); |
||
2291 | var data = buffer.char(); |
||
2292 | if (isWhitespace(data) && appropriate) { |
||
2293 | tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false}; |
||
2294 | tokenizer.setState(before_attribute_name_state); |
||
2295 | } else if (data === '/' && appropriate) { |
||
2296 | tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false}; |
||
2297 | tokenizer.setState(self_closing_tag_state); |
||
2298 | } else if (data === '>' && appropriate) { |
||
2299 | tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false}; |
||
2300 | tokenizer._emitCurrentToken(); |
||
2301 | tokenizer.setState(data_state); |
||
2302 | } else if (isAlpha(data)) { |
||
2303 | this._temporaryBuffer += data; |
||
2304 | buffer.commit(); |
||
2305 | } else { |
||
2306 | tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer}); |
||
2307 | buffer.unget(data); |
||
2308 | tokenizer.setState(rcdata_state); |
||
2309 | } |
||
2310 | return true; |
||
2311 | } |
||
2312 | |||
2313 | function rawtext_less_than_sign_state(buffer) { |
||
2314 | var data = buffer.char(); |
||
2315 | if (data === "/") { |
||
2316 | this._temporaryBuffer = ''; |
||
2317 | tokenizer.setState(rawtext_end_tag_open_state); |
||
2318 | } else { |
||
2319 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2320 | buffer.unget(data); |
||
2321 | tokenizer.setState(rawtext_state); |
||
2322 | } |
||
2323 | return true; |
||
2324 | } |
||
2325 | |||
2326 | function rawtext_end_tag_open_state(buffer) { |
||
2327 | var data = buffer.char(); |
||
2328 | if (isAlpha(data)) { |
||
2329 | this._temporaryBuffer += data; |
||
2330 | tokenizer.setState(rawtext_end_tag_name_state); |
||
2331 | } else { |
||
2332 | tokenizer._emitToken({type: 'Characters', data: '</'}); |
||
2333 | buffer.unget(data); |
||
2334 | tokenizer.setState(rawtext_state); |
||
2335 | } |
||
2336 | return true; |
||
2337 | } |
||
2338 | |||
2339 | function rawtext_end_tag_name_state(buffer) { |
||
2340 | var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase()); |
||
2341 | var data = buffer.char(); |
||
2342 | if (isWhitespace(data) && appropriate) { |
||
2343 | tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false}; |
||
2344 | tokenizer.setState(before_attribute_name_state); |
||
2345 | } else if (data === '/' && appropriate) { |
||
2346 | tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false}; |
||
2347 | tokenizer.setState(self_closing_tag_state); |
||
2348 | } else if (data === '>' && appropriate) { |
||
2349 | tokenizer._currentToken = {type: 'EndTag', name: this._temporaryBuffer, data: [], selfClosing: false}; |
||
2350 | tokenizer._emitCurrentToken(); |
||
2351 | tokenizer.setState(data_state); |
||
2352 | } else if (isAlpha(data)) { |
||
2353 | this._temporaryBuffer += data; |
||
2354 | buffer.commit(); |
||
2355 | } else { |
||
2356 | tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer}); |
||
2357 | buffer.unget(data); |
||
2358 | tokenizer.setState(rawtext_state); |
||
2359 | } |
||
2360 | return true; |
||
2361 | } |
||
2362 | |||
2363 | function script_data_less_than_sign_state(buffer) { |
||
2364 | var data = buffer.char(); |
||
2365 | if (data === "/") { |
||
2366 | this._temporaryBuffer = ''; |
||
2367 | tokenizer.setState(script_data_end_tag_open_state); |
||
2368 | } else if (data === '!') { |
||
2369 | tokenizer._emitToken({type: 'Characters', data: '<!'}); |
||
2370 | tokenizer.setState(script_data_escape_start_state); |
||
2371 | } else { |
||
2372 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2373 | buffer.unget(data); |
||
2374 | tokenizer.setState(script_data_state); |
||
2375 | } |
||
2376 | return true; |
||
2377 | } |
||
2378 | |||
2379 | function script_data_end_tag_open_state(buffer) { |
||
2380 | var data = buffer.char(); |
||
2381 | if (isAlpha(data)) { |
||
2382 | this._temporaryBuffer += data; |
||
2383 | tokenizer.setState(script_data_end_tag_name_state); |
||
2384 | } else { |
||
2385 | tokenizer._emitToken({type: 'Characters', data: '</'}); |
||
2386 | buffer.unget(data); |
||
2387 | tokenizer.setState(script_data_state); |
||
2388 | } |
||
2389 | return true; |
||
2390 | } |
||
2391 | |||
2392 | function script_data_end_tag_name_state(buffer) { |
||
2393 | var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase()); |
||
2394 | var data = buffer.char(); |
||
2395 | if (isWhitespace(data) && appropriate) { |
||
2396 | tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false}; |
||
2397 | tokenizer.setState(before_attribute_name_state); |
||
2398 | } else if (data === '/' && appropriate) { |
||
2399 | tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false}; |
||
2400 | tokenizer.setState(self_closing_tag_state); |
||
2401 | } else if (data === '>' && appropriate) { |
||
2402 | tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false}; |
||
2403 | tokenizer._emitCurrentToken(); |
||
2404 | } else if (isAlpha(data)) { |
||
2405 | this._temporaryBuffer += data; |
||
2406 | buffer.commit(); |
||
2407 | } else { |
||
2408 | tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer}); |
||
2409 | buffer.unget(data); |
||
2410 | tokenizer.setState(script_data_state); |
||
2411 | } |
||
2412 | return true; |
||
2413 | } |
||
2414 | |||
2415 | function script_data_escape_start_state(buffer) { |
||
2416 | var data = buffer.char(); |
||
2417 | if (data === '-') { |
||
2418 | tokenizer._emitToken({type: 'Characters', data: '-'}); |
||
2419 | tokenizer.setState(script_data_escape_start_dash_state); |
||
2420 | } else { |
||
2421 | buffer.unget(data); |
||
2422 | tokenizer.setState(script_data_state); |
||
2423 | } |
||
2424 | return true; |
||
2425 | } |
||
2426 | |||
2427 | function script_data_escape_start_dash_state(buffer) { |
||
2428 | var data = buffer.char(); |
||
2429 | if (data === '-') { |
||
2430 | tokenizer._emitToken({type: 'Characters', data: '-'}); |
||
2431 | tokenizer.setState(script_data_escaped_dash_dash_state); |
||
2432 | } else { |
||
2433 | buffer.unget(data); |
||
2434 | tokenizer.setState(script_data_state); |
||
2435 | } |
||
2436 | return true; |
||
2437 | } |
||
2438 | |||
2439 | function script_data_escaped_state(buffer) { |
||
2440 | var data = buffer.char(); |
||
2441 | if (data === InputStream.EOF) { |
||
2442 | buffer.unget(data); |
||
2443 | tokenizer.setState(data_state); |
||
2444 | } else if (data === '-') { |
||
2445 | tokenizer._emitToken({type: 'Characters', data: '-'}); |
||
2446 | tokenizer.setState(script_data_escaped_dash_state); |
||
2447 | } else if (data === '<') { |
||
2448 | tokenizer.setState(script_data_escaped_less_then_sign_state); |
||
2449 | } else if (data === '\u0000') { |
||
2450 | tokenizer._parseError("invalid-codepoint"); |
||
2451 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2452 | buffer.commit(); |
||
2453 | } else { |
||
2454 | var chars = buffer.matchUntil('<|-|\u0000'); |
||
2455 | tokenizer._emitToken({type: 'Characters', data: data + chars}); |
||
2456 | } |
||
2457 | return true; |
||
2458 | } |
||
2459 | |||
2460 | function script_data_escaped_dash_state(buffer) { |
||
2461 | var data = buffer.char(); |
||
2462 | if (data === InputStream.EOF) { |
||
2463 | buffer.unget(data); |
||
2464 | tokenizer.setState(data_state); |
||
2465 | } else if (data === '-') { |
||
2466 | tokenizer._emitToken({type: 'Characters', data: '-'}); |
||
2467 | tokenizer.setState(script_data_escaped_dash_dash_state); |
||
2468 | } else if (data === '<') { |
||
2469 | tokenizer.setState(script_data_escaped_less_then_sign_state); |
||
2470 | } else if (data === '\u0000') { |
||
2471 | tokenizer._parseError("invalid-codepoint"); |
||
2472 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2473 | tokenizer.setState(script_data_escaped_state); |
||
2474 | } else { |
||
2475 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2476 | tokenizer.setState(script_data_escaped_state); |
||
2477 | } |
||
2478 | return true; |
||
2479 | } |
||
2480 | |||
2481 | function script_data_escaped_dash_dash_state(buffer) { |
||
2482 | var data = buffer.char(); |
||
2483 | if (data === InputStream.EOF) { |
||
2484 | tokenizer._parseError('eof-in-script'); |
||
2485 | buffer.unget(data); |
||
2486 | tokenizer.setState(data_state); |
||
2487 | } else if (data === '<') { |
||
2488 | tokenizer.setState(script_data_escaped_less_then_sign_state); |
||
2489 | } else if (data === '>') { |
||
2490 | tokenizer._emitToken({type: 'Characters', data: '>'}); |
||
2491 | tokenizer.setState(script_data_state); |
||
2492 | } else if (data === '\u0000') { |
||
2493 | tokenizer._parseError("invalid-codepoint"); |
||
2494 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2495 | tokenizer.setState(script_data_escaped_state); |
||
2496 | } else { |
||
2497 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2498 | tokenizer.setState(script_data_escaped_state); |
||
2499 | } |
||
2500 | return true; |
||
2501 | } |
||
2502 | |||
2503 | function script_data_escaped_less_then_sign_state(buffer) { |
||
2504 | var data = buffer.char(); |
||
2505 | if (data === '/') { |
||
2506 | this._temporaryBuffer = ''; |
||
2507 | tokenizer.setState(script_data_escaped_end_tag_open_state); |
||
2508 | } else if (isAlpha(data)) { |
||
2509 | tokenizer._emitToken({type: 'Characters', data: '<' + data}); |
||
2510 | this._temporaryBuffer = data; |
||
2511 | tokenizer.setState(script_data_double_escape_start_state); |
||
2512 | } else { |
||
2513 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2514 | buffer.unget(data); |
||
2515 | tokenizer.setState(script_data_escaped_state); |
||
2516 | } |
||
2517 | return true; |
||
2518 | } |
||
2519 | |||
2520 | function script_data_escaped_end_tag_open_state(buffer) { |
||
2521 | var data = buffer.char(); |
||
2522 | if (isAlpha(data)) { |
||
2523 | this._temporaryBuffer = data; |
||
2524 | tokenizer.setState(script_data_escaped_end_tag_name_state); |
||
2525 | } else { |
||
2526 | tokenizer._emitToken({type: 'Characters', data: '</'}); |
||
2527 | buffer.unget(data); |
||
2528 | tokenizer.setState(script_data_escaped_state); |
||
2529 | } |
||
2530 | return true; |
||
2531 | } |
||
2532 | |||
2533 | function script_data_escaped_end_tag_name_state(buffer) { |
||
2534 | var appropriate = tokenizer._currentToken && (tokenizer._currentToken.name === this._temporaryBuffer.toLowerCase()); |
||
2535 | var data = buffer.char(); |
||
2536 | if (isWhitespace(data) && appropriate) { |
||
2537 | tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false}; |
||
2538 | tokenizer.setState(before_attribute_name_state); |
||
2539 | } else if (data === '/' && appropriate) { |
||
2540 | tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false}; |
||
2541 | tokenizer.setState(self_closing_tag_state); |
||
2542 | } else if (data === '>' && appropriate) { |
||
2543 | tokenizer._currentToken = {type: 'EndTag', name: 'script', data: [], selfClosing: false}; |
||
2544 | tokenizer.setState(data_state); |
||
2545 | tokenizer._emitCurrentToken(); |
||
2546 | } else if (isAlpha(data)) { |
||
2547 | this._temporaryBuffer += data; |
||
2548 | buffer.commit(); |
||
2549 | } else { |
||
2550 | tokenizer._emitToken({type: 'Characters', data: '</' + this._temporaryBuffer}); |
||
2551 | buffer.unget(data); |
||
2552 | tokenizer.setState(script_data_escaped_state); |
||
2553 | } |
||
2554 | return true; |
||
2555 | } |
||
2556 | |||
2557 | function script_data_double_escape_start_state(buffer) { |
||
2558 | var data = buffer.char(); |
||
2559 | if (isWhitespace(data) || data === '/' || data === '>') { |
||
2560 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2561 | if (this._temporaryBuffer.toLowerCase() === 'script') |
||
2562 | tokenizer.setState(script_data_double_escaped_state); |
||
2563 | else |
||
2564 | tokenizer.setState(script_data_escaped_state); |
||
2565 | } else if (isAlpha(data)) { |
||
2566 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2567 | this._temporaryBuffer += data; |
||
2568 | buffer.commit(); |
||
2569 | } else { |
||
2570 | buffer.unget(data); |
||
2571 | tokenizer.setState(script_data_escaped_state); |
||
2572 | } |
||
2573 | return true; |
||
2574 | } |
||
2575 | |||
2576 | function script_data_double_escaped_state(buffer) { |
||
2577 | var data = buffer.char(); |
||
2578 | if (data === InputStream.EOF) { |
||
2579 | tokenizer._parseError('eof-in-script'); |
||
2580 | buffer.unget(data); |
||
2581 | tokenizer.setState(data_state); |
||
2582 | } else if (data === '-') { |
||
2583 | tokenizer._emitToken({type: 'Characters', data: '-'}); |
||
2584 | tokenizer.setState(script_data_double_escaped_dash_state); |
||
2585 | } else if (data === '<') { |
||
2586 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2587 | tokenizer.setState(script_data_double_escaped_less_than_sign_state); |
||
2588 | } else if (data === '\u0000') { |
||
2589 | tokenizer._parseError('invalid-codepoint'); |
||
2590 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2591 | buffer.commit(); |
||
2592 | } else { |
||
2593 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2594 | buffer.commit(); |
||
2595 | } |
||
2596 | return true; |
||
2597 | } |
||
2598 | |||
2599 | function script_data_double_escaped_dash_state(buffer) { |
||
2600 | var data = buffer.char(); |
||
2601 | if (data === InputStream.EOF) { |
||
2602 | tokenizer._parseError('eof-in-script'); |
||
2603 | buffer.unget(data); |
||
2604 | tokenizer.setState(data_state); |
||
2605 | } else if (data === '-') { |
||
2606 | tokenizer._emitToken({type: 'Characters', data: '-'}); |
||
2607 | tokenizer.setState(script_data_double_escaped_dash_dash_state); |
||
2608 | } else if (data === '<') { |
||
2609 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2610 | tokenizer.setState(script_data_double_escaped_less_than_sign_state); |
||
2611 | } else if (data === '\u0000') { |
||
2612 | tokenizer._parseError('invalid-codepoint'); |
||
2613 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2614 | tokenizer.setState(script_data_double_escaped_state); |
||
2615 | } else { |
||
2616 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2617 | tokenizer.setState(script_data_double_escaped_state); |
||
2618 | } |
||
2619 | return true; |
||
2620 | } |
||
2621 | |||
2622 | function script_data_double_escaped_dash_dash_state(buffer) { |
||
2623 | var data = buffer.char(); |
||
2624 | if (data === InputStream.EOF) { |
||
2625 | tokenizer._parseError('eof-in-script'); |
||
2626 | buffer.unget(data); |
||
2627 | tokenizer.setState(data_state); |
||
2628 | } else if (data === '-') { |
||
2629 | tokenizer._emitToken({type: 'Characters', data: '-'}); |
||
2630 | buffer.commit(); |
||
2631 | } else if (data === '<') { |
||
2632 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2633 | tokenizer.setState(script_data_double_escaped_less_than_sign_state); |
||
2634 | } else if (data === '>') { |
||
2635 | tokenizer._emitToken({type: 'Characters', data: '>'}); |
||
2636 | tokenizer.setState(script_data_state); |
||
2637 | } else if (data === '\u0000') { |
||
2638 | tokenizer._parseError('invalid-codepoint'); |
||
2639 | tokenizer._emitToken({type: 'Characters', data: '\uFFFD'}); |
||
2640 | tokenizer.setState(script_data_double_escaped_state); |
||
2641 | } else { |
||
2642 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2643 | tokenizer.setState(script_data_double_escaped_state); |
||
2644 | } |
||
2645 | return true; |
||
2646 | } |
||
2647 | |||
2648 | function script_data_double_escaped_less_than_sign_state(buffer) { |
||
2649 | var data = buffer.char(); |
||
2650 | if (data === '/') { |
||
2651 | tokenizer._emitToken({type: 'Characters', data: '/'}); |
||
2652 | this._temporaryBuffer = ''; |
||
2653 | tokenizer.setState(script_data_double_escape_end_state); |
||
2654 | } else { |
||
2655 | buffer.unget(data); |
||
2656 | tokenizer.setState(script_data_double_escaped_state); |
||
2657 | } |
||
2658 | return true; |
||
2659 | } |
||
2660 | |||
2661 | function script_data_double_escape_end_state(buffer) { |
||
2662 | var data = buffer.char(); |
||
2663 | if (isWhitespace(data) || data === '/' || data === '>') { |
||
2664 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2665 | if (this._temporaryBuffer.toLowerCase() === 'script') |
||
2666 | tokenizer.setState(script_data_escaped_state); |
||
2667 | else |
||
2668 | tokenizer.setState(script_data_double_escaped_state); |
||
2669 | } else if (isAlpha(data)) { |
||
2670 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
2671 | this._temporaryBuffer += data; |
||
2672 | buffer.commit(); |
||
2673 | } else { |
||
2674 | buffer.unget(data); |
||
2675 | tokenizer.setState(script_data_double_escaped_state); |
||
2676 | } |
||
2677 | return true; |
||
2678 | } |
||
2679 | |||
2680 | function tag_open_state(buffer) { |
||
2681 | var data = buffer.char(); |
||
2682 | if (data === InputStream.EOF) { |
||
2683 | tokenizer._parseError("bare-less-than-sign-at-eof"); |
||
2684 | tokenizer._emitToken({type: 'Characters', data: '<'}); |
||
2685 | buffer.unget(data); |
||
2686 | tokenizer.setState(data_state); |
||
2687 | } else if (isAlpha(data)) { |
||
2688 | tokenizer._currentToken = {type: 'StartTag', name: data.toLowerCase(), data: []}; |
||
2689 | tokenizer.setState(tag_name_state); |
||
2690 | } else if (data === '!') { |
||
2691 | tokenizer.setState(markup_declaration_open_state); |
||
2692 | } else if (data === '/') { |
||
2693 | tokenizer.setState(close_tag_open_state); |
||
2694 | } else if (data === '>') { |
||
2695 | tokenizer._parseError("expected-tag-name-but-got-right-bracket"); |
||
2696 | tokenizer._emitToken({type: 'Characters', data: "<>"}); |
||
2697 | tokenizer.setState(data_state); |
||
2698 | } else if (data === '?') { |
||
2699 | tokenizer._parseError("expected-tag-name-but-got-question-mark"); |
||
2700 | buffer.unget(data); |
||
2701 | tokenizer.setState(bogus_comment_state); |
||
2702 | } else { |
||
2703 | tokenizer._parseError("expected-tag-name"); |
||
2704 | tokenizer._emitToken({type: 'Characters', data: "<"}); |
||
2705 | buffer.unget(data); |
||
2706 | tokenizer.setState(data_state); |
||
2707 | } |
||
2708 | return true; |
||
2709 | } |
||
2710 | |||
2711 | function close_tag_open_state(buffer) { |
||
2712 | var data = buffer.char(); |
||
2713 | if (data === InputStream.EOF) { |
||
2714 | tokenizer._parseError("expected-closing-tag-but-got-eof"); |
||
2715 | tokenizer._emitToken({type: 'Characters', data: '</'}); |
||
2716 | buffer.unget(data); |
||
2717 | tokenizer.setState(data_state); |
||
2718 | } else if (isAlpha(data)) { |
||
2719 | tokenizer._currentToken = {type: 'EndTag', name: data.toLowerCase(), data: []}; |
||
2720 | tokenizer.setState(tag_name_state); |
||
2721 | } else if (data === '>') { |
||
2722 | tokenizer._parseError("expected-closing-tag-but-got-right-bracket"); |
||
2723 | tokenizer.setState(data_state); |
||
2724 | } else { |
||
2725 | tokenizer._parseError("expected-closing-tag-but-got-char", {data: data}); // param 1 is datavars: |
||
2726 | buffer.unget(data); |
||
2727 | tokenizer.setState(bogus_comment_state); |
||
2728 | } |
||
2729 | return true; |
||
2730 | } |
||
2731 | |||
2732 | function tag_name_state(buffer) { |
||
2733 | var data = buffer.char(); |
||
2734 | if (data === InputStream.EOF) { |
||
2735 | tokenizer._parseError('eof-in-tag-name'); |
||
2736 | buffer.unget(data); |
||
2737 | tokenizer.setState(data_state); |
||
2738 | } else if (isWhitespace(data)) { |
||
2739 | tokenizer.setState(before_attribute_name_state); |
||
2740 | } else if (isAlpha(data)) { |
||
2741 | tokenizer._currentToken.name += data.toLowerCase(); |
||
2742 | } else if (data === '>') { |
||
2743 | tokenizer._emitCurrentToken(); |
||
2744 | } else if (data === '/') { |
||
2745 | tokenizer.setState(self_closing_tag_state); |
||
2746 | } else if (data === '\u0000') { |
||
2747 | tokenizer._parseError("invalid-codepoint"); |
||
2748 | tokenizer._currentToken.name += "\uFFFD"; |
||
2749 | } else { |
||
2750 | tokenizer._currentToken.name += data; |
||
2751 | } |
||
2752 | buffer.commit(); |
||
2753 | |||
2754 | return true; |
||
2755 | } |
||
2756 | |||
2757 | function before_attribute_name_state(buffer) { |
||
2758 | var data = buffer.char(); |
||
2759 | if (data === InputStream.EOF) { |
||
2760 | tokenizer._parseError("expected-attribute-name-but-got-eof"); |
||
2761 | buffer.unget(data); |
||
2762 | tokenizer.setState(data_state); |
||
2763 | } else if (isWhitespace(data)) { |
||
2764 | return true; |
||
2765 | } else if (isAlpha(data)) { |
||
2766 | tokenizer._currentToken.data.push({nodeName: data.toLowerCase(), nodeValue: ""}); |
||
2767 | tokenizer.setState(attribute_name_state); |
||
2768 | } else if (data === '>') { |
||
2769 | tokenizer._emitCurrentToken(); |
||
2770 | } else if (data === '/') { |
||
2771 | tokenizer.setState(self_closing_tag_state); |
||
2772 | } else if (data === "'" || data === '"' || data === '=' || data === '<') { |
||
2773 | tokenizer._parseError("invalid-character-in-attribute-name"); |
||
2774 | tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""}); |
||
2775 | tokenizer.setState(attribute_name_state); |
||
2776 | } else if (data === '\u0000') { |
||
2777 | tokenizer._parseError("invalid-codepoint"); |
||
2778 | tokenizer._currentToken.data.push({nodeName: "\uFFFD", nodeValue: ""}); |
||
2779 | } else { |
||
2780 | tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""}); |
||
2781 | tokenizer.setState(attribute_name_state); |
||
2782 | } |
||
2783 | return true; |
||
2784 | } |
||
2785 | |||
2786 | function attribute_name_state(buffer) { |
||
2787 | var data = buffer.char(); |
||
2788 | var leavingThisState = true; |
||
2789 | var shouldEmit = false; |
||
2790 | if (data === InputStream.EOF) { |
||
2791 | tokenizer._parseError("eof-in-attribute-name"); |
||
2792 | buffer.unget(data); |
||
2793 | tokenizer.setState(data_state); |
||
2794 | shouldEmit = true; |
||
2795 | } else if (data === '=') { |
||
2796 | tokenizer.setState(before_attribute_value_state); |
||
2797 | } else if (isAlpha(data)) { |
||
2798 | tokenizer._currentAttribute().nodeName += data.toLowerCase(); |
||
2799 | leavingThisState = false; |
||
2800 | } else if (data === '>') { |
||
2801 | shouldEmit = true; |
||
2802 | } else if (isWhitespace(data)) { |
||
2803 | tokenizer.setState(after_attribute_name_state); |
||
2804 | } else if (data === '/') { |
||
2805 | tokenizer.setState(self_closing_tag_state); |
||
2806 | } else if (data === "'" || data === '"') { |
||
2807 | tokenizer._parseError("invalid-character-in-attribute-name"); |
||
2808 | tokenizer._currentAttribute().nodeName += data; |
||
2809 | leavingThisState = false; |
||
2810 | } else if (data === '\u0000') { |
||
2811 | tokenizer._parseError("invalid-codepoint"); |
||
2812 | tokenizer._currentAttribute().nodeName += "\uFFFD"; |
||
2813 | } else { |
||
2814 | tokenizer._currentAttribute().nodeName += data; |
||
2815 | leavingThisState = false; |
||
2816 | } |
||
2817 | |||
2818 | if (leavingThisState) { |
||
2819 | var attributes = tokenizer._currentToken.data; |
||
2820 | var currentAttribute = attributes[attributes.length - 1]; |
||
2821 | for (var i = attributes.length - 2; i >= 0; i--) { |
||
2822 | if (currentAttribute.nodeName === attributes[i].nodeName) { |
||
2823 | tokenizer._parseError("duplicate-attribute", {name: currentAttribute.nodeName}); |
||
2824 | currentAttribute.nodeName = null; |
||
2825 | break; |
||
2826 | } |
||
2827 | } |
||
2828 | if (shouldEmit) |
||
2829 | tokenizer._emitCurrentToken(); |
||
2830 | } else { |
||
2831 | buffer.commit(); |
||
2832 | } |
||
2833 | return true; |
||
2834 | } |
||
2835 | |||
2836 | function after_attribute_name_state(buffer) { |
||
2837 | var data = buffer.char(); |
||
2838 | if (data === InputStream.EOF) { |
||
2839 | tokenizer._parseError("expected-end-of-tag-but-got-eof"); |
||
2840 | buffer.unget(data); |
||
2841 | tokenizer.setState(data_state); |
||
2842 | } else if (isWhitespace(data)) { |
||
2843 | return true; |
||
2844 | } else if (data === '=') { |
||
2845 | tokenizer.setState(before_attribute_value_state); |
||
2846 | } else if (data === '>') { |
||
2847 | tokenizer._emitCurrentToken(); |
||
2848 | } else if (isAlpha(data)) { |
||
2849 | tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""}); |
||
2850 | tokenizer.setState(attribute_name_state); |
||
2851 | } else if (data === '/') { |
||
2852 | tokenizer.setState(self_closing_tag_state); |
||
2853 | } else if (data === "'" || data === '"' || data === '<') { |
||
2854 | tokenizer._parseError("invalid-character-after-attribute-name"); |
||
2855 | tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""}); |
||
2856 | tokenizer.setState(attribute_name_state); |
||
2857 | } else if (data === '\u0000') { |
||
2858 | tokenizer._parseError("invalid-codepoint"); |
||
2859 | tokenizer._currentToken.data.push({nodeName: "\uFFFD", nodeValue: ""}); |
||
2860 | } else { |
||
2861 | tokenizer._currentToken.data.push({nodeName: data, nodeValue: ""}); |
||
2862 | tokenizer.setState(attribute_name_state); |
||
2863 | } |
||
2864 | return true; |
||
2865 | } |
||
2866 | |||
2867 | function before_attribute_value_state(buffer) { |
||
2868 | var data = buffer.char(); |
||
2869 | if (data === InputStream.EOF) { |
||
2870 | tokenizer._parseError("expected-attribute-value-but-got-eof"); |
||
2871 | buffer.unget(data); |
||
2872 | tokenizer.setState(data_state); |
||
2873 | } else if (isWhitespace(data)) { |
||
2874 | return true; |
||
2875 | } else if (data === '"') { |
||
2876 | tokenizer.setState(attribute_value_double_quoted_state); |
||
2877 | } else if (data === '&') { |
||
2878 | tokenizer.setState(attribute_value_unquoted_state); |
||
2879 | buffer.unget(data); |
||
2880 | } else if (data === "'") { |
||
2881 | tokenizer.setState(attribute_value_single_quoted_state); |
||
2882 | } else if (data === '>') { |
||
2883 | tokenizer._parseError("expected-attribute-value-but-got-right-bracket"); |
||
2884 | tokenizer._emitCurrentToken(); |
||
2885 | } else if (data === '=' || data === '<' || data === '`') { |
||
2886 | tokenizer._parseError("unexpected-character-in-unquoted-attribute-value"); |
||
2887 | tokenizer._currentAttribute().nodeValue += data; |
||
2888 | tokenizer.setState(attribute_value_unquoted_state); |
||
2889 | } else if (data === '\u0000') { |
||
2890 | tokenizer._parseError("invalid-codepoint"); |
||
2891 | tokenizer._currentAttribute().nodeValue += "\uFFFD"; |
||
2892 | } else { |
||
2893 | tokenizer._currentAttribute().nodeValue += data; |
||
2894 | tokenizer.setState(attribute_value_unquoted_state); |
||
2895 | } |
||
2896 | |||
2897 | return true; |
||
2898 | } |
||
2899 | |||
2900 | function attribute_value_double_quoted_state(buffer) { |
||
2901 | var data = buffer.char(); |
||
2902 | if (data === InputStream.EOF) { |
||
2903 | tokenizer._parseError("eof-in-attribute-value-double-quote"); |
||
2904 | buffer.unget(data); |
||
2905 | tokenizer.setState(data_state); |
||
2906 | } else if (data === '"') { |
||
2907 | tokenizer.setState(after_attribute_value_state); |
||
2908 | } else if (data === '&') { |
||
2909 | this._additionalAllowedCharacter = '"'; |
||
2910 | tokenizer.setState(character_reference_in_attribute_value_state); |
||
2911 | } else if (data === '\u0000') { |
||
2912 | tokenizer._parseError("invalid-codepoint"); |
||
2913 | tokenizer._currentAttribute().nodeValue += "\uFFFD"; |
||
2914 | } else { |
||
2915 | var s = buffer.matchUntil('[\0"&]'); |
||
2916 | data = data + s; |
||
2917 | tokenizer._currentAttribute().nodeValue += data; |
||
2918 | } |
||
2919 | return true; |
||
2920 | } |
||
2921 | |||
2922 | function attribute_value_single_quoted_state(buffer) { |
||
2923 | var data = buffer.char(); |
||
2924 | if (data === InputStream.EOF) { |
||
2925 | tokenizer._parseError("eof-in-attribute-value-single-quote"); |
||
2926 | buffer.unget(data); |
||
2927 | tokenizer.setState(data_state); |
||
2928 | } else if (data === "'") { |
||
2929 | tokenizer.setState(after_attribute_value_state); |
||
2930 | } else if (data === '&') { |
||
2931 | this._additionalAllowedCharacter = "'"; |
||
2932 | tokenizer.setState(character_reference_in_attribute_value_state); |
||
2933 | } else if (data === '\u0000') { |
||
2934 | tokenizer._parseError("invalid-codepoint"); |
||
2935 | tokenizer._currentAttribute().nodeValue += "\uFFFD"; |
||
2936 | } else { |
||
2937 | tokenizer._currentAttribute().nodeValue += data + buffer.matchUntil("\u0000|['&]"); |
||
2938 | } |
||
2939 | return true; |
||
2940 | } |
||
2941 | |||
2942 | function attribute_value_unquoted_state(buffer) { |
||
2943 | var data = buffer.char(); |
||
2944 | if (data === InputStream.EOF) { |
||
2945 | tokenizer._parseError("eof-after-attribute-value"); |
||
2946 | buffer.unget(data); |
||
2947 | tokenizer.setState(data_state); |
||
2948 | } else if (isWhitespace(data)) { |
||
2949 | tokenizer.setState(before_attribute_name_state); |
||
2950 | } else if (data === '&') { |
||
2951 | this._additionalAllowedCharacter = ">"; |
||
2952 | tokenizer.setState(character_reference_in_attribute_value_state); |
||
2953 | } else if (data === '>') { |
||
2954 | tokenizer._emitCurrentToken(); |
||
2955 | } else if (data === '"' || data === "'" || data === '=' || data === '`' || data === '<') { |
||
2956 | tokenizer._parseError("unexpected-character-in-unquoted-attribute-value"); |
||
2957 | tokenizer._currentAttribute().nodeValue += data; |
||
2958 | buffer.commit(); |
||
2959 | } else if (data === '\u0000') { |
||
2960 | tokenizer._parseError("invalid-codepoint"); |
||
2961 | tokenizer._currentAttribute().nodeValue += "\uFFFD"; |
||
2962 | } else { |
||
2963 | var o = buffer.matchUntil("\u0000|["+ "\t\n\v\f\x20\r" + "&<>\"'=`" +"]"); |
||
2964 | if (o === InputStream.EOF) { |
||
2965 | tokenizer._parseError("eof-in-attribute-value-no-quotes"); |
||
2966 | tokenizer._emitCurrentToken(); |
||
2967 | } |
||
2968 | buffer.commit(); |
||
2969 | tokenizer._currentAttribute().nodeValue += data + o; |
||
2970 | } |
||
2971 | return true; |
||
2972 | } |
||
2973 | |||
2974 | function character_reference_in_attribute_value_state(buffer) { |
||
2975 | var character = EntityParser.consumeEntity(buffer, tokenizer, this._additionalAllowedCharacter); |
||
2976 | this._currentAttribute().nodeValue += character || '&'; |
||
2977 | if (this._additionalAllowedCharacter === '"') |
||
2978 | tokenizer.setState(attribute_value_double_quoted_state); |
||
2979 | else if (this._additionalAllowedCharacter === '\'') |
||
2980 | tokenizer.setState(attribute_value_single_quoted_state); |
||
2981 | else if (this._additionalAllowedCharacter === '>') |
||
2982 | tokenizer.setState(attribute_value_unquoted_state); |
||
2983 | return true; |
||
2984 | } |
||
2985 | |||
2986 | function after_attribute_value_state(buffer) { |
||
2987 | var data = buffer.char(); |
||
2988 | if (data === InputStream.EOF) { |
||
2989 | tokenizer._parseError("eof-after-attribute-value"); |
||
2990 | buffer.unget(data); |
||
2991 | tokenizer.setState(data_state); |
||
2992 | } else if (isWhitespace(data)) { |
||
2993 | tokenizer.setState(before_attribute_name_state); |
||
2994 | } else if (data === '>') { |
||
2995 | tokenizer.setState(data_state); |
||
2996 | tokenizer._emitCurrentToken(); |
||
2997 | } else if (data === '/') { |
||
2998 | tokenizer.setState(self_closing_tag_state); |
||
2999 | } else { |
||
3000 | tokenizer._parseError("unexpected-character-after-attribute-value"); |
||
3001 | buffer.unget(data); |
||
3002 | tokenizer.setState(before_attribute_name_state); |
||
3003 | } |
||
3004 | return true; |
||
3005 | } |
||
3006 | |||
3007 | function self_closing_tag_state(buffer) { |
||
3008 | var c = buffer.char(); |
||
3009 | if (c === InputStream.EOF) { |
||
3010 | tokenizer._parseError("unexpected-eof-after-solidus-in-tag"); |
||
3011 | buffer.unget(c); |
||
3012 | tokenizer.setState(data_state); |
||
3013 | } else if (c === '>') { |
||
3014 | tokenizer._currentToken.selfClosing = true; |
||
3015 | tokenizer.setState(data_state); |
||
3016 | tokenizer._emitCurrentToken(); |
||
3017 | } else { |
||
3018 | tokenizer._parseError("unexpected-character-after-solidus-in-tag"); |
||
3019 | buffer.unget(c); |
||
3020 | tokenizer.setState(before_attribute_name_state); |
||
3021 | } |
||
3022 | return true; |
||
3023 | } |
||
3024 | |||
3025 | function bogus_comment_state(buffer) { |
||
3026 | var data = buffer.matchUntil('>'); |
||
3027 | data = data.replace(/\u0000/g, "\uFFFD"); |
||
3028 | buffer.char(); |
||
3029 | tokenizer._emitToken({type: 'Comment', data: data}); |
||
3030 | tokenizer.setState(data_state); |
||
3031 | return true; |
||
3032 | } |
||
3033 | |||
3034 | function markup_declaration_open_state(buffer) { |
||
3035 | var chars = buffer.shift(2); |
||
3036 | if (chars === '--') { |
||
3037 | tokenizer._currentToken = {type: 'Comment', data: ''}; |
||
3038 | tokenizer.setState(comment_start_state); |
||
3039 | } else { |
||
3040 | var newchars = buffer.shift(5); |
||
3041 | if (newchars === InputStream.EOF || chars === InputStream.EOF) { |
||
3042 | tokenizer._parseError("expected-dashes-or-doctype"); |
||
3043 | tokenizer.setState(bogus_comment_state); |
||
3044 | buffer.unget(chars); |
||
3045 | return true; |
||
3046 | } |
||
3047 | |||
3048 | chars += newchars; |
||
3049 | if (chars.toUpperCase() === 'DOCTYPE') { |
||
3050 | tokenizer._currentToken = {type: 'Doctype', name: '', publicId: null, systemId: null, forceQuirks: false}; |
||
3051 | tokenizer.setState(doctype_state); |
||
3052 | } else if (tokenizer._tokenHandler.isCdataSectionAllowed() && chars === '[CDATA[') { |
||
3053 | tokenizer.setState(cdata_section_state); |
||
3054 | } else { |
||
3055 | tokenizer._parseError("expected-dashes-or-doctype"); |
||
3056 | buffer.unget(chars); |
||
3057 | tokenizer.setState(bogus_comment_state); |
||
3058 | } |
||
3059 | } |
||
3060 | return true; |
||
3061 | } |
||
3062 | |||
3063 | function cdata_section_state(buffer) { |
||
3064 | var data = buffer.matchUntil(']]>'); |
||
3065 | buffer.shift(3); |
||
3066 | if (data) { |
||
3067 | tokenizer._emitToken({type: 'Characters', data: data}); |
||
3068 | } |
||
3069 | tokenizer.setState(data_state); |
||
3070 | return true; |
||
3071 | } |
||
3072 | |||
3073 | function comment_start_state(buffer) { |
||
3074 | var data = buffer.char(); |
||
3075 | if (data === InputStream.EOF) { |
||
3076 | tokenizer._parseError("eof-in-comment"); |
||
3077 | tokenizer._emitToken(tokenizer._currentToken); |
||
3078 | buffer.unget(data); |
||
3079 | tokenizer.setState(data_state); |
||
3080 | } else if (data === '-') { |
||
3081 | tokenizer.setState(comment_start_dash_state); |
||
3082 | } else if (data === '>') { |
||
3083 | tokenizer._parseError("incorrect-comment"); |
||
3084 | tokenizer._emitToken(tokenizer._currentToken); |
||
3085 | tokenizer.setState(data_state); |
||
3086 | } else if (data === '\u0000') { |
||
3087 | tokenizer._parseError("invalid-codepoint"); |
||
3088 | tokenizer._currentToken.data += "\uFFFD"; |
||
3089 | } else { |
||
3090 | tokenizer._currentToken.data += data; |
||
3091 | tokenizer.setState(comment_state); |
||
3092 | } |
||
3093 | return true; |
||
3094 | } |
||
3095 | |||
3096 | function comment_start_dash_state(buffer) { |
||
3097 | var data = buffer.char(); |
||
3098 | if (data === InputStream.EOF) { |
||
3099 | tokenizer._parseError("eof-in-comment"); |
||
3100 | tokenizer._emitToken(tokenizer._currentToken); |
||
3101 | buffer.unget(data); |
||
3102 | tokenizer.setState(data_state); |
||
3103 | } else if (data === '-') { |
||
3104 | tokenizer.setState(comment_end_state); |
||
3105 | } else if (data === '>') { |
||
3106 | tokenizer._parseError("incorrect-comment"); |
||
3107 | tokenizer._emitToken(tokenizer._currentToken); |
||
3108 | tokenizer.setState(data_state); |
||
3109 | } else if (data === '\u0000') { |
||
3110 | tokenizer._parseError("invalid-codepoint"); |
||
3111 | tokenizer._currentToken.data += "\uFFFD"; |
||
3112 | } else { |
||
3113 | tokenizer._currentToken.data += '-' + data; |
||
3114 | tokenizer.setState(comment_state); |
||
3115 | } |
||
3116 | return true; |
||
3117 | } |
||
3118 | |||
3119 | function comment_state(buffer) { |
||
3120 | var data = buffer.char(); |
||
3121 | if (data === InputStream.EOF) { |
||
3122 | tokenizer._parseError("eof-in-comment"); |
||
3123 | tokenizer._emitToken(tokenizer._currentToken); |
||
3124 | buffer.unget(data); |
||
3125 | tokenizer.setState(data_state); |
||
3126 | } else if (data === '-') { |
||
3127 | tokenizer.setState(comment_end_dash_state); |
||
3128 | } else if (data === '\u0000') { |
||
3129 | tokenizer._parseError("invalid-codepoint"); |
||
3130 | tokenizer._currentToken.data += "\uFFFD"; |
||
3131 | } else { |
||
3132 | tokenizer._currentToken.data += data; |
||
3133 | buffer.commit(); |
||
3134 | } |
||
3135 | return true; |
||
3136 | } |
||
3137 | |||
3138 | function comment_end_dash_state(buffer) { |
||
3139 | var data = buffer.char(); |
||
3140 | if (data === InputStream.EOF) { |
||
3141 | tokenizer._parseError("eof-in-comment-end-dash"); |
||
3142 | tokenizer._emitToken(tokenizer._currentToken); |
||
3143 | buffer.unget(data); |
||
3144 | tokenizer.setState(data_state); |
||
3145 | } else if (data === '-') { |
||
3146 | tokenizer.setState(comment_end_state); |
||
3147 | } else if (data === '\u0000') { |
||
3148 | tokenizer._parseError("invalid-codepoint"); |
||
3149 | tokenizer._currentToken.data += "-\uFFFD"; |
||
3150 | tokenizer.setState(comment_state); |
||
3151 | } else { |
||
3152 | tokenizer._currentToken.data += '-' + data + buffer.matchUntil('\u0000|-'); |
||
3153 | buffer.char(); |
||
3154 | } |
||
3155 | return true; |
||
3156 | } |
||
3157 | |||
3158 | function comment_end_state(buffer) { |
||
3159 | var data = buffer.char(); |
||
3160 | if (data === InputStream.EOF) { |
||
3161 | tokenizer._parseError("eof-in-comment-double-dash"); |
||
3162 | tokenizer._emitToken(tokenizer._currentToken); |
||
3163 | buffer.unget(data); |
||
3164 | tokenizer.setState(data_state); |
||
3165 | } else if (data === '>') { |
||
3166 | tokenizer._emitToken(tokenizer._currentToken); |
||
3167 | tokenizer.setState(data_state); |
||
3168 | } else if (data === '!') { |
||
3169 | tokenizer._parseError("unexpected-bang-after-double-dash-in-comment"); |
||
3170 | tokenizer.setState(comment_end_bang_state); |
||
3171 | } else if (data === '-') { |
||
3172 | tokenizer._parseError("unexpected-dash-after-double-dash-in-comment"); |
||
3173 | tokenizer._currentToken.data += data; |
||
3174 | } else if (data === '\u0000') { |
||
3175 | tokenizer._parseError("invalid-codepoint"); |
||
3176 | tokenizer._currentToken.data += "--\uFFFD"; |
||
3177 | tokenizer.setState(comment_state); |
||
3178 | } else { |
||
3179 | tokenizer._parseError("unexpected-char-in-comment"); |
||
3180 | tokenizer._currentToken.data += '--' + data; |
||
3181 | tokenizer.setState(comment_state); |
||
3182 | } |
||
3183 | return true; |
||
3184 | } |
||
3185 | |||
3186 | function comment_end_bang_state(buffer) { |
||
3187 | var data = buffer.char(); |
||
3188 | if (data === InputStream.EOF) { |
||
3189 | tokenizer._parseError("eof-in-comment-end-bang-state"); |
||
3190 | tokenizer._emitToken(tokenizer._currentToken); |
||
3191 | buffer.unget(data); |
||
3192 | tokenizer.setState(data_state); |
||
3193 | } else if (data === '>') { |
||
3194 | tokenizer._emitToken(tokenizer._currentToken); |
||
3195 | tokenizer.setState(data_state); |
||
3196 | } else if (data === '-') { |
||
3197 | tokenizer._currentToken.data += '--!'; |
||
3198 | tokenizer.setState(comment_end_dash_state); |
||
3199 | } else { |
||
3200 | tokenizer._currentToken.data += '--!' + data; |
||
3201 | tokenizer.setState(comment_state); |
||
3202 | } |
||
3203 | return true; |
||
3204 | } |
||
3205 | |||
3206 | function doctype_state(buffer) { |
||
3207 | var data = buffer.char(); |
||
3208 | if (data === InputStream.EOF) { |
||
3209 | tokenizer._parseError("expected-doctype-name-but-got-eof"); |
||
3210 | tokenizer._currentToken.forceQuirks = true; |
||
3211 | buffer.unget(data); |
||
3212 | tokenizer.setState(data_state); |
||
3213 | tokenizer._emitCurrentToken(); |
||
3214 | } else if (isWhitespace(data)) { |
||
3215 | tokenizer.setState(before_doctype_name_state); |
||
3216 | } else { |
||
3217 | tokenizer._parseError("need-space-after-doctype"); |
||
3218 | buffer.unget(data); |
||
3219 | tokenizer.setState(before_doctype_name_state); |
||
3220 | } |
||
3221 | return true; |
||
3222 | } |
||
3223 | |||
3224 | function before_doctype_name_state(buffer) { |
||
3225 | var data = buffer.char(); |
||
3226 | if (data === InputStream.EOF) { |
||
3227 | tokenizer._parseError("expected-doctype-name-but-got-eof"); |
||
3228 | tokenizer._currentToken.forceQuirks = true; |
||
3229 | buffer.unget(data); |
||
3230 | tokenizer.setState(data_state); |
||
3231 | tokenizer._emitCurrentToken(); |
||
3232 | } else if (isWhitespace(data)) { |
||
3233 | } else if (data === '>') { |
||
3234 | tokenizer._parseError("expected-doctype-name-but-got-right-bracket"); |
||
3235 | tokenizer._currentToken.forceQuirks = true; |
||
3236 | tokenizer.setState(data_state); |
||
3237 | tokenizer._emitCurrentToken(); |
||
3238 | } else { |
||
3239 | if (isAlpha(data)) |
||
3240 | data = data.toLowerCase(); |
||
3241 | tokenizer._currentToken.name = data; |
||
3242 | tokenizer.setState(doctype_name_state); |
||
3243 | } |
||
3244 | return true; |
||
3245 | } |
||
3246 | |||
3247 | function doctype_name_state(buffer) { |
||
3248 | var data = buffer.char(); |
||
3249 | if (data === InputStream.EOF) { |
||
3250 | tokenizer._currentToken.forceQuirks = true; |
||
3251 | buffer.unget(data); |
||
3252 | tokenizer._parseError("eof-in-doctype-name"); |
||
3253 | tokenizer.setState(data_state); |
||
3254 | tokenizer._emitCurrentToken(); |
||
3255 | } else if (isWhitespace(data)) { |
||
3256 | tokenizer.setState(after_doctype_name_state); |
||
3257 | } else if (data === '>') { |
||
3258 | tokenizer.setState(data_state); |
||
3259 | tokenizer._emitCurrentToken(); |
||
3260 | } else { |
||
3261 | if (isAlpha(data)) |
||
3262 | data = data.toLowerCase(); |
||
3263 | tokenizer._currentToken.name += data; |
||
3264 | buffer.commit(); |
||
3265 | } |
||
3266 | return true; |
||
3267 | } |
||
3268 | |||
3269 | function after_doctype_name_state(buffer) { |
||
3270 | var data = buffer.char(); |
||
3271 | if (data === InputStream.EOF) { |
||
3272 | tokenizer._currentToken.forceQuirks = true; |
||
3273 | buffer.unget(data); |
||
3274 | tokenizer._parseError("eof-in-doctype"); |
||
3275 | tokenizer.setState(data_state); |
||
3276 | tokenizer._emitCurrentToken(); |
||
3277 | } else if (isWhitespace(data)) { |
||
3278 | } else if (data === '>') { |
||
3279 | tokenizer.setState(data_state); |
||
3280 | tokenizer._emitCurrentToken(); |
||
3281 | } else { |
||
3282 | if (['p', 'P'].indexOf(data) > -1) { |
||
3283 | var expected = [['u', 'U'], ['b', 'B'], ['l', 'L'], ['i', 'I'], ['c', 'C']]; |
||
3284 | var matched = expected.every(function(expected){ |
||
3285 | data = buffer.char(); |
||
3286 | return expected.indexOf(data) > -1; |
||
3287 | }); |
||
3288 | if (matched) { |
||
3289 | tokenizer.setState(after_doctype_public_keyword_state); |
||
3290 | return true; |
||
3291 | } |
||
3292 | } else if (['s', 'S'].indexOf(data) > -1) { |
||
3293 | var expected = [['y', 'Y'], ['s', 'S'], ['t', 'T'], ['e', 'E'], ['m', 'M']]; |
||
3294 | var matched = expected.every(function(expected){ |
||
3295 | data = buffer.char(); |
||
3296 | return expected.indexOf(data) > -1; |
||
3297 | }); |
||
3298 | if (matched) { |
||
3299 | tokenizer.setState(after_doctype_system_keyword_state); |
||
3300 | return true; |
||
3301 | } |
||
3302 | } |
||
3303 | buffer.unget(data); |
||
3304 | tokenizer._currentToken.forceQuirks = true; |
||
3305 | |||
3306 | if (data === InputStream.EOF) { |
||
3307 | tokenizer._parseError("eof-in-doctype"); |
||
3308 | buffer.unget(data); |
||
3309 | tokenizer.setState(data_state); |
||
3310 | tokenizer._emitCurrentToken(); |
||
3311 | } else { |
||
3312 | tokenizer._parseError("expected-space-or-right-bracket-in-doctype", {data: data}); |
||
3313 | tokenizer.setState(bogus_doctype_state); |
||
3314 | } |
||
3315 | } |
||
3316 | return true; |
||
3317 | } |
||
3318 | |||
3319 | function after_doctype_public_keyword_state(buffer) { |
||
3320 | var data = buffer.char(); |
||
3321 | if (data === InputStream.EOF) { |
||
3322 | tokenizer._parseError("eof-in-doctype"); |
||
3323 | tokenizer._currentToken.forceQuirks = true; |
||
3324 | buffer.unget(data); |
||
3325 | tokenizer.setState(data_state); |
||
3326 | tokenizer._emitCurrentToken(); |
||
3327 | } else if (isWhitespace(data)) { |
||
3328 | tokenizer.setState(before_doctype_public_identifier_state); |
||
3329 | } else if (data === "'" || data === '"') { |
||
3330 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3331 | buffer.unget(data); |
||
3332 | tokenizer.setState(before_doctype_public_identifier_state); |
||
3333 | } else { |
||
3334 | buffer.unget(data); |
||
3335 | tokenizer.setState(before_doctype_public_identifier_state); |
||
3336 | } |
||
3337 | return true; |
||
3338 | } |
||
3339 | |||
3340 | function before_doctype_public_identifier_state(buffer) { |
||
3341 | var data = buffer.char(); |
||
3342 | if (data === InputStream.EOF) { |
||
3343 | tokenizer._parseError("eof-in-doctype"); |
||
3344 | tokenizer._currentToken.forceQuirks = true; |
||
3345 | buffer.unget(data); |
||
3346 | tokenizer.setState(data_state); |
||
3347 | tokenizer._emitCurrentToken(); |
||
3348 | } else if (isWhitespace(data)) { |
||
3349 | } else if (data === '"') { |
||
3350 | tokenizer._currentToken.publicId = ''; |
||
3351 | tokenizer.setState(doctype_public_identifier_double_quoted_state); |
||
3352 | } else if (data === "'") { |
||
3353 | tokenizer._currentToken.publicId = ''; |
||
3354 | tokenizer.setState(doctype_public_identifier_single_quoted_state); |
||
3355 | } else if (data === '>') { |
||
3356 | tokenizer._parseError("unexpected-end-of-doctype"); |
||
3357 | tokenizer._currentToken.forceQuirks = true; |
||
3358 | tokenizer.setState(data_state); |
||
3359 | tokenizer._emitCurrentToken(); |
||
3360 | } else { |
||
3361 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3362 | tokenizer._currentToken.forceQuirks = true; |
||
3363 | tokenizer.setState(bogus_doctype_state); |
||
3364 | } |
||
3365 | return true; |
||
3366 | } |
||
3367 | |||
3368 | function doctype_public_identifier_double_quoted_state(buffer) { |
||
3369 | var data = buffer.char(); |
||
3370 | if (data === InputStream.EOF) { |
||
3371 | tokenizer._parseError("eof-in-doctype"); |
||
3372 | tokenizer._currentToken.forceQuirks = true; |
||
3373 | buffer.unget(data); |
||
3374 | tokenizer.setState(data_state); |
||
3375 | tokenizer._emitCurrentToken(); |
||
3376 | } else if (data === '"') { |
||
3377 | tokenizer.setState(after_doctype_public_identifier_state); |
||
3378 | } else if (data === '>') { |
||
3379 | tokenizer._parseError("unexpected-end-of-doctype"); |
||
3380 | tokenizer._currentToken.forceQuirks = true; |
||
3381 | tokenizer.setState(data_state); |
||
3382 | tokenizer._emitCurrentToken(); |
||
3383 | } else { |
||
3384 | tokenizer._currentToken.publicId += data; |
||
3385 | } |
||
3386 | return true; |
||
3387 | } |
||
3388 | |||
3389 | function doctype_public_identifier_single_quoted_state(buffer) { |
||
3390 | var data = buffer.char(); |
||
3391 | if (data === InputStream.EOF) { |
||
3392 | tokenizer._parseError("eof-in-doctype"); |
||
3393 | tokenizer._currentToken.forceQuirks = true; |
||
3394 | buffer.unget(data); |
||
3395 | tokenizer.setState(data_state); |
||
3396 | tokenizer._emitCurrentToken(); |
||
3397 | } else if (data === "'") { |
||
3398 | tokenizer.setState(after_doctype_public_identifier_state); |
||
3399 | } else if (data === '>') { |
||
3400 | tokenizer._parseError("unexpected-end-of-doctype"); |
||
3401 | tokenizer._currentToken.forceQuirks = true; |
||
3402 | tokenizer.setState(data_state); |
||
3403 | tokenizer._emitCurrentToken(); |
||
3404 | } else { |
||
3405 | tokenizer._currentToken.publicId += data; |
||
3406 | } |
||
3407 | return true; |
||
3408 | } |
||
3409 | |||
3410 | function after_doctype_public_identifier_state(buffer) { |
||
3411 | var data = buffer.char(); |
||
3412 | if (data === InputStream.EOF) { |
||
3413 | tokenizer._parseError("eof-in-doctype"); |
||
3414 | tokenizer._currentToken.forceQuirks = true; |
||
3415 | tokenizer._emitCurrentToken(); |
||
3416 | buffer.unget(data); |
||
3417 | tokenizer.setState(data_state); |
||
3418 | } else if (isWhitespace(data)) { |
||
3419 | tokenizer.setState(between_doctype_public_and_system_identifiers_state); |
||
3420 | } else if (data === '>') { |
||
3421 | tokenizer.setState(data_state); |
||
3422 | tokenizer._emitCurrentToken(); |
||
3423 | } else if (data === '"') { |
||
3424 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3425 | tokenizer._currentToken.systemId = ''; |
||
3426 | tokenizer.setState(doctype_system_identifier_double_quoted_state); |
||
3427 | } else if (data === "'") { |
||
3428 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3429 | tokenizer._currentToken.systemId = ''; |
||
3430 | tokenizer.setState(doctype_system_identifier_single_quoted_state); |
||
3431 | } else { |
||
3432 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3433 | tokenizer._currentToken.forceQuirks = true; |
||
3434 | tokenizer.setState(bogus_doctype_state); |
||
3435 | } |
||
3436 | return true; |
||
3437 | } |
||
3438 | |||
3439 | function between_doctype_public_and_system_identifiers_state(buffer) { |
||
3440 | var data = buffer.char(); |
||
3441 | if (data === InputStream.EOF) { |
||
3442 | tokenizer._parseError("eof-in-doctype"); |
||
3443 | tokenizer._currentToken.forceQuirks = true; |
||
3444 | tokenizer._emitCurrentToken(); |
||
3445 | buffer.unget(data); |
||
3446 | tokenizer.setState(data_state); |
||
3447 | } else if (isWhitespace(data)) { |
||
3448 | } else if (data === '>') { |
||
3449 | tokenizer._emitCurrentToken(); |
||
3450 | tokenizer.setState(data_state); |
||
3451 | } else if (data === '"') { |
||
3452 | tokenizer._currentToken.systemId = ''; |
||
3453 | tokenizer.setState(doctype_system_identifier_double_quoted_state); |
||
3454 | } else if (data === "'") { |
||
3455 | tokenizer._currentToken.systemId = ''; |
||
3456 | tokenizer.setState(doctype_system_identifier_single_quoted_state); |
||
3457 | } else { |
||
3458 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3459 | tokenizer._currentToken.forceQuirks = true; |
||
3460 | tokenizer.setState(bogus_doctype_state); |
||
3461 | } |
||
3462 | return true; |
||
3463 | } |
||
3464 | |||
3465 | function after_doctype_system_keyword_state(buffer) { |
||
3466 | var data = buffer.char(); |
||
3467 | if (data === InputStream.EOF) { |
||
3468 | tokenizer._parseError("eof-in-doctype"); |
||
3469 | tokenizer._currentToken.forceQuirks = true; |
||
3470 | tokenizer._emitCurrentToken(); |
||
3471 | buffer.unget(data); |
||
3472 | tokenizer.setState(data_state); |
||
3473 | } else if (isWhitespace(data)) { |
||
3474 | tokenizer.setState(before_doctype_system_identifier_state); |
||
3475 | } else if (data === "'" || data === '"') { |
||
3476 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3477 | buffer.unget(data); |
||
3478 | tokenizer.setState(before_doctype_system_identifier_state); |
||
3479 | } else { |
||
3480 | buffer.unget(data); |
||
3481 | tokenizer.setState(before_doctype_system_identifier_state); |
||
3482 | } |
||
3483 | return true; |
||
3484 | } |
||
3485 | |||
3486 | function before_doctype_system_identifier_state(buffer) { |
||
3487 | var data = buffer.char(); |
||
3488 | if (data === InputStream.EOF) { |
||
3489 | tokenizer._parseError("eof-in-doctype"); |
||
3490 | tokenizer._currentToken.forceQuirks = true; |
||
3491 | tokenizer._emitCurrentToken(); |
||
3492 | buffer.unget(data); |
||
3493 | tokenizer.setState(data_state); |
||
3494 | } else if (isWhitespace(data)) { |
||
3495 | } else if (data === '"') { |
||
3496 | tokenizer._currentToken.systemId = ''; |
||
3497 | tokenizer.setState(doctype_system_identifier_double_quoted_state); |
||
3498 | } else if (data === "'") { |
||
3499 | tokenizer._currentToken.systemId = ''; |
||
3500 | tokenizer.setState(doctype_system_identifier_single_quoted_state); |
||
3501 | } else if (data === '>') { |
||
3502 | tokenizer._parseError("unexpected-end-of-doctype"); |
||
3503 | tokenizer._currentToken.forceQuirks = true; |
||
3504 | tokenizer._emitCurrentToken(); |
||
3505 | tokenizer.setState(data_state); |
||
3506 | } else { |
||
3507 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3508 | tokenizer._currentToken.forceQuirks = true; |
||
3509 | tokenizer.setState(bogus_doctype_state); |
||
3510 | } |
||
3511 | return true; |
||
3512 | } |
||
3513 | |||
3514 | function doctype_system_identifier_double_quoted_state(buffer) { |
||
3515 | var data = buffer.char(); |
||
3516 | if (data === InputStream.EOF) { |
||
3517 | tokenizer._parseError("eof-in-doctype"); |
||
3518 | tokenizer._currentToken.forceQuirks = true; |
||
3519 | tokenizer._emitCurrentToken(); |
||
3520 | buffer.unget(data); |
||
3521 | tokenizer.setState(data_state); |
||
3522 | } else if (data === '"') { |
||
3523 | tokenizer.setState(after_doctype_system_identifier_state); |
||
3524 | } else if (data === '>') { |
||
3525 | tokenizer._parseError("unexpected-end-of-doctype"); |
||
3526 | tokenizer._currentToken.forceQuirks = true; |
||
3527 | tokenizer._emitCurrentToken(); |
||
3528 | tokenizer.setState(data_state); |
||
3529 | } else { |
||
3530 | tokenizer._currentToken.systemId += data; |
||
3531 | } |
||
3532 | return true; |
||
3533 | } |
||
3534 | |||
3535 | function doctype_system_identifier_single_quoted_state(buffer) { |
||
3536 | var data = buffer.char(); |
||
3537 | if (data === InputStream.EOF) { |
||
3538 | tokenizer._parseError("eof-in-doctype"); |
||
3539 | tokenizer._currentToken.forceQuirks = true; |
||
3540 | tokenizer._emitCurrentToken(); |
||
3541 | buffer.unget(data); |
||
3542 | tokenizer.setState(data_state); |
||
3543 | } else if (data === "'") { |
||
3544 | tokenizer.setState(after_doctype_system_identifier_state); |
||
3545 | } else if (data === '>') { |
||
3546 | tokenizer._parseError("unexpected-end-of-doctype"); |
||
3547 | tokenizer._currentToken.forceQuirks = true; |
||
3548 | tokenizer._emitCurrentToken(); |
||
3549 | tokenizer.setState(data_state); |
||
3550 | } else { |
||
3551 | tokenizer._currentToken.systemId += data; |
||
3552 | } |
||
3553 | return true; |
||
3554 | } |
||
3555 | |||
3556 | function after_doctype_system_identifier_state(buffer) { |
||
3557 | var data = buffer.char(); |
||
3558 | if (data === InputStream.EOF) { |
||
3559 | tokenizer._parseError("eof-in-doctype"); |
||
3560 | tokenizer._currentToken.forceQuirks = true; |
||
3561 | tokenizer._emitCurrentToken(); |
||
3562 | buffer.unget(data); |
||
3563 | tokenizer.setState(data_state); |
||
3564 | } else if (isWhitespace(data)) { |
||
3565 | } else if (data === '>') { |
||
3566 | tokenizer._emitCurrentToken(); |
||
3567 | tokenizer.setState(data_state); |
||
3568 | } else { |
||
3569 | tokenizer._parseError("unexpected-char-in-doctype"); |
||
3570 | tokenizer.setState(bogus_doctype_state); |
||
3571 | } |
||
3572 | return true; |
||
3573 | } |
||
3574 | |||
3575 | function bogus_doctype_state(buffer) { |
||
3576 | var data = buffer.char(); |
||
3577 | if (data === InputStream.EOF) { |
||
3578 | buffer.unget(data); |
||
3579 | tokenizer._emitCurrentToken(); |
||
3580 | tokenizer.setState(data_state); |
||
3581 | } else if (data === '>') { |
||
3582 | tokenizer._emitCurrentToken(); |
||
3583 | tokenizer.setState(data_state); |
||
3584 | } |
||
3585 | return true; |
||
3586 | } |
||
3587 | }; |
||
3588 | |||
3589 | Object.defineProperty(Tokenizer.prototype, 'lineNumber', { |
||
3590 | get: function() { |
||
3591 | return this._inputStream.location().line; |
||
3592 | } |
||
3593 | }); |
||
3594 | |||
3595 | Object.defineProperty(Tokenizer.prototype, 'columnNumber', { |
||
3596 | get: function() { |
||
3597 | return this._inputStream.location().column; |
||
3598 | } |
||
3599 | }); |
||
3600 | |||
3601 | exports.Tokenizer = Tokenizer; |
||
3602 | |||
3603 | }, |
||
3604 | {"./EntityParser":2,"./InputStream":3}], |
||
3605 | 6:[function(_dereq_,module,exports){ |
||
3606 | var assert = _dereq_('assert'); |
||
3607 | |||
3608 | var messages = _dereq_('./messages.json'); |
||
3609 | var constants = _dereq_('./constants'); |
||
3610 | |||
3611 | var EventEmitter = _dereq_('events').EventEmitter; |
||
3612 | |||
3613 | var Tokenizer = _dereq_('./Tokenizer').Tokenizer; |
||
3614 | var ElementStack = _dereq_('./ElementStack').ElementStack; |
||
3615 | var StackItem = _dereq_('./StackItem').StackItem; |
||
3616 | |||
3617 | var Marker = {}; |
||
3618 | |||
3619 | function isWhitespace(ch) { |
||
3620 | return ch === " " || ch === "\n" || ch === "\t" || ch === "\r" || ch === "\f"; |
||
3621 | } |
||
3622 | |||
3623 | function isWhitespaceOrReplacementCharacter(ch) { |
||
3624 | return isWhitespace(ch) || ch === '\uFFFD'; |
||
3625 | } |
||
3626 | |||
3627 | function isAllWhitespace(characters) { |
||
3628 | for (var i = 0; i < characters.length; i++) { |
||
3629 | var ch = characters[i]; |
||
3630 | if (!isWhitespace(ch)) |
||
3631 | return false; |
||
3632 | } |
||
3633 | return true; |
||
3634 | } |
||
3635 | |||
3636 | function isAllWhitespaceOrReplacementCharacters(characters) { |
||
3637 | for (var i = 0; i < characters.length; i++) { |
||
3638 | var ch = characters[i]; |
||
3639 | if (!isWhitespaceOrReplacementCharacter(ch)) |
||
3640 | return false; |
||
3641 | } |
||
3642 | return true; |
||
3643 | } |
||
3644 | |||
3645 | function getAttribute(node, name) { |
||
3646 | for (var i = 0; i < node.attributes.length; i++) { |
||
3647 | var attribute = node.attributes[i]; |
||
3648 | if (attribute.nodeName === name) { |
||
3649 | return attribute; |
||
3650 | } |
||
3651 | } |
||
3652 | return null; |
||
3653 | } |
||
3654 | |||
3655 | function CharacterBuffer(characters) { |
||
3656 | this.characters = characters; |
||
3657 | this.current = 0; |
||
3658 | this.end = this.characters.length; |
||
3659 | } |
||
3660 | |||
3661 | CharacterBuffer.prototype.skipAtMostOneLeadingNewline = function() { |
||
3662 | if (this.characters[this.current] === '\n') |
||
3663 | this.current++; |
||
3664 | }; |
||
3665 | |||
3666 | CharacterBuffer.prototype.skipLeadingWhitespace = function() { |
||
3667 | while (isWhitespace(this.characters[this.current])) { |
||
3668 | if (++this.current == this.end) |
||
3669 | return; |
||
3670 | } |
||
3671 | }; |
||
3672 | |||
3673 | CharacterBuffer.prototype.skipLeadingNonWhitespace = function() { |
||
3674 | while (!isWhitespace(this.characters[this.current])) { |
||
3675 | if (++this.current == this.end) |
||
3676 | return; |
||
3677 | } |
||
3678 | }; |
||
3679 | |||
3680 | CharacterBuffer.prototype.takeRemaining = function() { |
||
3681 | return this.characters.substring(this.current); |
||
3682 | }; |
||
3683 | |||
3684 | CharacterBuffer.prototype.takeLeadingWhitespace = function() { |
||
3685 | var start = this.current; |
||
3686 | this.skipLeadingWhitespace(); |
||
3687 | if (start === this.current) |
||
3688 | return ""; |
||
3689 | return this.characters.substring(start, this.current - start); |
||
3690 | }; |
||
3691 | |||
3692 | Object.defineProperty(CharacterBuffer.prototype, 'length', { |
||
3693 | get: function(){ |
||
3694 | return this.end - this.current; |
||
3695 | } |
||
3696 | }); |
||
3697 | function TreeBuilder() { |
||
3698 | this.tokenizer = null; |
||
3699 | this.errorHandler = null; |
||
3700 | this.scriptingEnabled = false; |
||
3701 | this.document = null; |
||
3702 | this.head = null; |
||
3703 | this.form = null; |
||
3704 | this.openElements = new ElementStack(); |
||
3705 | this.activeFormattingElements = []; |
||
3706 | this.insertionMode = null; |
||
3707 | this.insertionModeName = ""; |
||
3708 | this.originalInsertionMode = ""; |
||
3709 | this.inQuirksMode = false; // TODO quirks mode |
||
3710 | this.compatMode = "no quirks"; |
||
3711 | this.framesetOk = true; |
||
3712 | this.redirectAttachToFosterParent = false; |
||
3713 | this.selfClosingFlagAcknowledged = false; |
||
3714 | this.context = ""; |
||
3715 | this.pendingTableCharacters = []; |
||
3716 | this.shouldSkipLeadingNewline = false; |
||
3717 | |||
3718 | var tree = this; |
||
3719 | var modes = this.insertionModes = {}; |
||
3720 | modes.base = { |
||
3721 | end_tag_handlers: {"-default": 'endTagOther'}, |
||
3722 | start_tag_handlers: {"-default": 'startTagOther'}, |
||
3723 | processEOF: function() { |
||
3724 | tree.generateImpliedEndTags(); |
||
3725 | if (tree.openElements.length > 2) { |
||
3726 | tree.parseError('expected-closing-tag-but-got-eof'); |
||
3727 | } else if (tree.openElements.length == 2 && |
||
3728 | tree.openElements.item(1).localName != 'body') { |
||
3729 | tree.parseError('expected-closing-tag-but-got-eof'); |
||
3730 | } else if (tree.context && tree.openElements.length > 1) { |
||
3731 | } |
||
3732 | }, |
||
3733 | processComment: function(data) { |
||
3734 | tree.insertComment(data, tree.currentStackItem().node); |
||
3735 | }, |
||
3736 | processDoctype: function(name, publicId, systemId, forceQuirks) { |
||
3737 | tree.parseError('unexpected-doctype'); |
||
3738 | }, |
||
3739 | processStartTag: function(name, attributes, selfClosing) { |
||
3740 | if (this[this.start_tag_handlers[name]]) { |
||
3741 | this[this.start_tag_handlers[name]](name, attributes, selfClosing); |
||
3742 | } else if (this[this.start_tag_handlers["-default"]]) { |
||
3743 | this[this.start_tag_handlers["-default"]](name, attributes, selfClosing); |
||
3744 | } else { |
||
3745 | throw(new Error("No handler found for "+name)); |
||
3746 | } |
||
3747 | }, |
||
3748 | processEndTag: function(name) { |
||
3749 | if (this[this.end_tag_handlers[name]]) { |
||
3750 | this[this.end_tag_handlers[name]](name); |
||
3751 | } else if (this[this.end_tag_handlers["-default"]]) { |
||
3752 | this[this.end_tag_handlers["-default"]](name); |
||
3753 | } else { |
||
3754 | throw(new Error("No handler found for "+name)); |
||
3755 | } |
||
3756 | }, |
||
3757 | startTagHtml: function(name, attributes) { |
||
3758 | modes.inBody.startTagHtml(name, attributes); |
||
3759 | } |
||
3760 | }; |
||
3761 | |||
3762 | modes.initial = Object.create(modes.base); |
||
3763 | |||
3764 | modes.initial.processEOF = function() { |
||
3765 | tree.parseError("expected-doctype-but-got-eof"); |
||
3766 | this.anythingElse(); |
||
3767 | tree.insertionMode.processEOF(); |
||
3768 | }; |
||
3769 | |||
3770 | modes.initial.processComment = function(data) { |
||
3771 | tree.insertComment(data, tree.document); |
||
3772 | }; |
||
3773 | |||
3774 | modes.initial.processDoctype = function(name, publicId, systemId, forceQuirks) { |
||
3775 | tree.insertDoctype(name || '', publicId || '', systemId || ''); |
||
3776 | |||
3777 | if (forceQuirks || name != 'html' || (publicId != null && ([ |
||
3778 | "+//silmaril//dtd html pro v0r11 19970101//", |
||
3779 | "-//advasoft ltd//dtd html 3.0 aswedit + extensions//", |
||
3780 | "-//as//dtd html 3.0 aswedit + extensions//", |
||
3781 | "-//ietf//dtd html 2.0 level 1//", |
||
3782 | "-//ietf//dtd html 2.0 level 2//", |
||
3783 | "-//ietf//dtd html 2.0 strict level 1//", |
||
3784 | "-//ietf//dtd html 2.0 strict level 2//", |
||
3785 | "-//ietf//dtd html 2.0 strict//", |
||
3786 | "-//ietf//dtd html 2.0//", |
||
3787 | "-//ietf//dtd html 2.1e//", |
||
3788 | "-//ietf//dtd html 3.0//", |
||
3789 | "-//ietf//dtd html 3.0//", |
||
3790 | "-//ietf//dtd html 3.2 final//", |
||
3791 | "-//ietf//dtd html 3.2//", |
||
3792 | "-//ietf//dtd html 3//", |
||
3793 | "-//ietf//dtd html level 0//", |
||
3794 | "-//ietf//dtd html level 0//", |
||
3795 | "-//ietf//dtd html level 1//", |
||
3796 | "-//ietf//dtd html level 1//", |
||
3797 | "-//ietf//dtd html level 2//", |
||
3798 | "-//ietf//dtd html level 2//", |
||
3799 | "-//ietf//dtd html level 3//", |
||
3800 | "-//ietf//dtd html level 3//", |
||
3801 | "-//ietf//dtd html strict level 0//", |
||
3802 | "-//ietf//dtd html strict level 0//", |
||
3803 | "-//ietf//dtd html strict level 1//", |
||
3804 | "-//ietf//dtd html strict level 1//", |
||
3805 | "-//ietf//dtd html strict level 2//", |
||
3806 | "-//ietf//dtd html strict level 2//", |
||
3807 | "-//ietf//dtd html strict level 3//", |
||
3808 | "-//ietf//dtd html strict level 3//", |
||
3809 | "-//ietf//dtd html strict//", |
||
3810 | "-//ietf//dtd html strict//", |
||
3811 | "-//ietf//dtd html strict//", |
||
3812 | "-//ietf//dtd html//", |
||
3813 | "-//ietf//dtd html//", |
||
3814 | "-//ietf//dtd html//", |
||
3815 | "-//metrius//dtd metrius presentational//", |
||
3816 | "-//microsoft//dtd internet explorer 2.0 html strict//", |
||
3817 | "-//microsoft//dtd internet explorer 2.0 html//", |
||
3818 | "-//microsoft//dtd internet explorer 2.0 tables//", |
||
3819 | "-//microsoft//dtd internet explorer 3.0 html strict//", |
||
3820 | "-//microsoft//dtd internet explorer 3.0 html//", |
||
3821 | "-//microsoft//dtd internet explorer 3.0 tables//", |
||
3822 | "-//netscape comm. corp.//dtd html//", |
||
3823 | "-//netscape comm. corp.//dtd strict html//", |
||
3824 | "-//o'reilly and associates//dtd html 2.0//", |
||
3825 | "-//o'reilly and associates//dtd html extended 1.0//", |
||
3826 | "-//spyglass//dtd html 2.0 extended//", |
||
3827 | "-//sq//dtd html 2.0 hotmetal + extensions//", |
||
3828 | "-//sun microsystems corp.//dtd hotjava html//", |
||
3829 | "-//sun microsystems corp.//dtd hotjava strict html//", |
||
3830 | "-//w3c//dtd html 3 1995-03-24//", |
||
3831 | "-//w3c//dtd html 3.2 draft//", |
||
3832 | "-//w3c//dtd html 3.2 final//", |
||
3833 | "-//w3c//dtd html 3.2//", |
||
3834 | "-//w3c//dtd html 3.2s draft//", |
||
3835 | "-//w3c//dtd html 4.0 frameset//", |
||
3836 | "-//w3c//dtd html 4.0 transitional//", |
||
3837 | "-//w3c//dtd html experimental 19960712//", |
||
3838 | "-//w3c//dtd html experimental 970421//", |
||
3839 | "-//w3c//dtd w3 html//", |
||
3840 | "-//w3o//dtd w3 html 3.0//", |
||
3841 | "-//webtechs//dtd mozilla html 2.0//", |
||
3842 | "-//webtechs//dtd mozilla html//", |
||
3843 | "html" |
||
3844 | ].some(publicIdStartsWith) |
||
3845 | || [ |
||
3846 | "-//w3o//dtd w3 html strict 3.0//en//", |
||
3847 | "-/w3c/dtd html 4.0 transitional/en", |
||
3848 | "html" |
||
3849 | ].indexOf(publicId.toLowerCase()) > -1 |
||
3850 | || (systemId == null && [ |
||
3851 | "-//w3c//dtd html 4.01 transitional//", |
||
3852 | "-//w3c//dtd html 4.01 frameset//" |
||
3853 | ].some(publicIdStartsWith))) |
||
3854 | ) |
||
3855 | || (systemId != null && (systemId.toLowerCase() == "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd")) |
||
3856 | ) { |
||
3857 | tree.compatMode = "quirks"; |
||
3858 | tree.parseError("quirky-doctype"); |
||
3859 | } else if (publicId != null && ([ |
||
3860 | "-//w3c//dtd xhtml 1.0 transitional//", |
||
3861 | "-//w3c//dtd xhtml 1.0 frameset//" |
||
3862 | ].some(publicIdStartsWith) |
||
3863 | || (systemId != null && [ |
||
3864 | "-//w3c//dtd html 4.01 transitional//", |
||
3865 | "-//w3c//dtd html 4.01 frameset//" |
||
3866 | ].indexOf(publicId.toLowerCase()) > -1)) |
||
3867 | ) { |
||
3868 | tree.compatMode = "limited quirks"; |
||
3869 | tree.parseError("almost-standards-doctype"); |
||
3870 | } else { |
||
3871 | if ((publicId == "-//W3C//DTD HTML 4.0//EN" && (systemId == null || systemId == "http://www.w3.org/TR/REC-html40/strict.dtd")) |
||
3872 | || (publicId == "-//W3C//DTD HTML 4.01//EN" && (systemId == null || systemId == "http://www.w3.org/TR/html4/strict.dtd")) |
||
3873 | || (publicId == "-//W3C//DTD XHTML 1.0 Strict//EN" && (systemId == "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd")) |
||
3874 | || (publicId == "-//W3C//DTD XHTML 1.1//EN" && (systemId == "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd")) |
||
3875 | ) { |
||
3876 | } else if (!((systemId == null || systemId == "about:legacy-compat") && publicId == null)) { |
||
3877 | tree.parseError("unknown-doctype"); |
||
3878 | } |
||
3879 | } |
||
3880 | tree.setInsertionMode('beforeHTML'); |
||
3881 | function publicIdStartsWith(string) { |
||
3882 | return publicId.toLowerCase().indexOf(string) === 0; |
||
3883 | } |
||
3884 | }; |
||
3885 | |||
3886 | modes.initial.processCharacters = function(buffer) { |
||
3887 | buffer.skipLeadingWhitespace(); |
||
3888 | if (!buffer.length) |
||
3889 | return; |
||
3890 | tree.parseError('expected-doctype-but-got-chars'); |
||
3891 | this.anythingElse(); |
||
3892 | tree.insertionMode.processCharacters(buffer); |
||
3893 | }; |
||
3894 | |||
3895 | modes.initial.processStartTag = function(name, attributes, selfClosing) { |
||
3896 | tree.parseError('expected-doctype-but-got-start-tag', {name: name}); |
||
3897 | this.anythingElse(); |
||
3898 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
3899 | }; |
||
3900 | |||
3901 | modes.initial.processEndTag = function(name) { |
||
3902 | tree.parseError('expected-doctype-but-got-end-tag', {name: name}); |
||
3903 | this.anythingElse(); |
||
3904 | tree.insertionMode.processEndTag(name); |
||
3905 | }; |
||
3906 | |||
3907 | modes.initial.anythingElse = function() { |
||
3908 | tree.compatMode = 'quirks'; |
||
3909 | tree.setInsertionMode('beforeHTML'); |
||
3910 | }; |
||
3911 | |||
3912 | modes.beforeHTML = Object.create(modes.base); |
||
3913 | |||
3914 | modes.beforeHTML.start_tag_handlers = { |
||
3915 | html: 'startTagHtml', |
||
3916 | '-default': 'startTagOther' |
||
3917 | }; |
||
3918 | |||
3919 | modes.beforeHTML.processEOF = function() { |
||
3920 | this.anythingElse(); |
||
3921 | tree.insertionMode.processEOF(); |
||
3922 | }; |
||
3923 | |||
3924 | modes.beforeHTML.processComment = function(data) { |
||
3925 | tree.insertComment(data, tree.document); |
||
3926 | }; |
||
3927 | |||
3928 | modes.beforeHTML.processCharacters = function(buffer) { |
||
3929 | buffer.skipLeadingWhitespace(); |
||
3930 | if (!buffer.length) |
||
3931 | return; |
||
3932 | this.anythingElse(); |
||
3933 | tree.insertionMode.processCharacters(buffer); |
||
3934 | }; |
||
3935 | |||
3936 | modes.beforeHTML.startTagHtml = function(name, attributes, selfClosing) { |
||
3937 | tree.insertHtmlElement(attributes); |
||
3938 | tree.setInsertionMode('beforeHead'); |
||
3939 | }; |
||
3940 | |||
3941 | modes.beforeHTML.startTagOther = function(name, attributes, selfClosing) { |
||
3942 | this.anythingElse(); |
||
3943 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
3944 | }; |
||
3945 | |||
3946 | modes.beforeHTML.processEndTag = function(name) { |
||
3947 | this.anythingElse(); |
||
3948 | tree.insertionMode.processEndTag(name); |
||
3949 | }; |
||
3950 | |||
3951 | modes.beforeHTML.anythingElse = function() { |
||
3952 | tree.insertHtmlElement(); |
||
3953 | tree.setInsertionMode('beforeHead'); |
||
3954 | }; |
||
3955 | |||
3956 | modes.afterAfterBody = Object.create(modes.base); |
||
3957 | |||
3958 | modes.afterAfterBody.start_tag_handlers = { |
||
3959 | html: 'startTagHtml', |
||
3960 | '-default': 'startTagOther' |
||
3961 | }; |
||
3962 | |||
3963 | modes.afterAfterBody.processComment = function(data) { |
||
3964 | tree.insertComment(data, tree.document); |
||
3965 | }; |
||
3966 | |||
3967 | modes.afterAfterBody.processDoctype = function(data) { |
||
3968 | modes.inBody.processDoctype(data); |
||
3969 | }; |
||
3970 | |||
3971 | modes.afterAfterBody.startTagHtml = function(data, attributes) { |
||
3972 | modes.inBody.startTagHtml(data, attributes); |
||
3973 | }; |
||
3974 | |||
3975 | modes.afterAfterBody.startTagOther = function(name, attributes, selfClosing) { |
||
3976 | tree.parseError('unexpected-start-tag', {name: name}); |
||
3977 | tree.setInsertionMode('inBody'); |
||
3978 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
3979 | }; |
||
3980 | |||
3981 | modes.afterAfterBody.endTagOther = function(name) { |
||
3982 | tree.parseError('unexpected-end-tag', {name: name}); |
||
3983 | tree.setInsertionMode('inBody'); |
||
3984 | tree.insertionMode.processEndTag(name); |
||
3985 | }; |
||
3986 | |||
3987 | modes.afterAfterBody.processCharacters = function(data) { |
||
3988 | if (!isAllWhitespace(data.characters)) { |
||
3989 | tree.parseError('unexpected-char-after-body'); |
||
3990 | tree.setInsertionMode('inBody'); |
||
3991 | return tree.insertionMode.processCharacters(data); |
||
3992 | } |
||
3993 | modes.inBody.processCharacters(data); |
||
3994 | }; |
||
3995 | |||
3996 | modes.afterBody = Object.create(modes.base); |
||
3997 | |||
3998 | modes.afterBody.end_tag_handlers = { |
||
3999 | html: 'endTagHtml', |
||
4000 | '-default': 'endTagOther' |
||
4001 | }; |
||
4002 | |||
4003 | modes.afterBody.processComment = function(data) { |
||
4004 | tree.insertComment(data, tree.openElements.rootNode); |
||
4005 | }; |
||
4006 | |||
4007 | modes.afterBody.processCharacters = function(data) { |
||
4008 | if (!isAllWhitespace(data.characters)) { |
||
4009 | tree.parseError('unexpected-char-after-body'); |
||
4010 | tree.setInsertionMode('inBody'); |
||
4011 | return tree.insertionMode.processCharacters(data); |
||
4012 | } |
||
4013 | modes.inBody.processCharacters(data); |
||
4014 | }; |
||
4015 | |||
4016 | modes.afterBody.processStartTag = function(name, attributes, selfClosing) { |
||
4017 | tree.parseError('unexpected-start-tag-after-body', {name: name}); |
||
4018 | tree.setInsertionMode('inBody'); |
||
4019 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
4020 | }; |
||
4021 | |||
4022 | modes.afterBody.endTagHtml = function(name) { |
||
4023 | if (tree.context) { |
||
4024 | tree.parseError('end-html-in-innerhtml'); |
||
4025 | } else { |
||
4026 | tree.setInsertionMode('afterAfterBody'); |
||
4027 | } |
||
4028 | }; |
||
4029 | |||
4030 | modes.afterBody.endTagOther = function(name) { |
||
4031 | tree.parseError('unexpected-end-tag-after-body', {name: name}); |
||
4032 | tree.setInsertionMode('inBody'); |
||
4033 | tree.insertionMode.processEndTag(name); |
||
4034 | }; |
||
4035 | |||
4036 | modes.afterFrameset = Object.create(modes.base); |
||
4037 | |||
4038 | modes.afterFrameset.start_tag_handlers = { |
||
4039 | html: 'startTagHtml', |
||
4040 | noframes: 'startTagNoframes', |
||
4041 | '-default': 'startTagOther' |
||
4042 | }; |
||
4043 | |||
4044 | modes.afterFrameset.end_tag_handlers = { |
||
4045 | html: 'endTagHtml', |
||
4046 | '-default': 'endTagOther' |
||
4047 | }; |
||
4048 | |||
4049 | modes.afterFrameset.processCharacters = function(buffer) { |
||
4050 | var characters = buffer.takeRemaining(); |
||
4051 | var whitespace = ""; |
||
4052 | for (var i = 0; i < characters.length; i++) { |
||
4053 | var ch = characters[i]; |
||
4054 | if (isWhitespace(ch)) |
||
4055 | whitespace += ch; |
||
4056 | } |
||
4057 | if (whitespace) { |
||
4058 | tree.insertText(whitespace); |
||
4059 | } |
||
4060 | if (whitespace.length < characters.length) |
||
4061 | tree.parseError('expected-eof-but-got-char'); |
||
4062 | }; |
||
4063 | |||
4064 | modes.afterFrameset.startTagNoframes = function(name, attributes) { |
||
4065 | modes.inHead.processStartTag(name, attributes); |
||
4066 | }; |
||
4067 | |||
4068 | modes.afterFrameset.startTagOther = function(name, attributes) { |
||
4069 | tree.parseError("unexpected-start-tag-after-frameset", {name: name}); |
||
4070 | }; |
||
4071 | |||
4072 | modes.afterFrameset.endTagHtml = function(name) { |
||
4073 | tree.setInsertionMode('afterAfterFrameset'); |
||
4074 | }; |
||
4075 | |||
4076 | modes.afterFrameset.endTagOther = function(name) { |
||
4077 | tree.parseError("unexpected-end-tag-after-frameset", {name: name}); |
||
4078 | }; |
||
4079 | |||
4080 | modes.beforeHead = Object.create(modes.base); |
||
4081 | |||
4082 | modes.beforeHead.start_tag_handlers = { |
||
4083 | html: 'startTagHtml', |
||
4084 | head: 'startTagHead', |
||
4085 | '-default': 'startTagOther' |
||
4086 | }; |
||
4087 | |||
4088 | modes.beforeHead.end_tag_handlers = { |
||
4089 | html: 'endTagImplyHead', |
||
4090 | head: 'endTagImplyHead', |
||
4091 | body: 'endTagImplyHead', |
||
4092 | br: 'endTagImplyHead', |
||
4093 | '-default': 'endTagOther' |
||
4094 | }; |
||
4095 | |||
4096 | modes.beforeHead.processEOF = function() { |
||
4097 | this.startTagHead('head', []); |
||
4098 | tree.insertionMode.processEOF(); |
||
4099 | }; |
||
4100 | |||
4101 | modes.beforeHead.processCharacters = function(buffer) { |
||
4102 | buffer.skipLeadingWhitespace(); |
||
4103 | if (!buffer.length) |
||
4104 | return; |
||
4105 | this.startTagHead('head', []); |
||
4106 | tree.insertionMode.processCharacters(buffer); |
||
4107 | }; |
||
4108 | |||
4109 | modes.beforeHead.startTagHead = function(name, attributes) { |
||
4110 | tree.insertHeadElement(attributes); |
||
4111 | tree.setInsertionMode('inHead'); |
||
4112 | }; |
||
4113 | |||
4114 | modes.beforeHead.startTagOther = function(name, attributes, selfClosing) { |
||
4115 | this.startTagHead('head', []); |
||
4116 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
4117 | }; |
||
4118 | |||
4119 | modes.beforeHead.endTagImplyHead = function(name) { |
||
4120 | this.startTagHead('head', []); |
||
4121 | tree.insertionMode.processEndTag(name); |
||
4122 | }; |
||
4123 | |||
4124 | modes.beforeHead.endTagOther = function(name) { |
||
4125 | tree.parseError('end-tag-after-implied-root', {name: name}); |
||
4126 | }; |
||
4127 | |||
4128 | modes.inHead = Object.create(modes.base); |
||
4129 | |||
4130 | modes.inHead.start_tag_handlers = { |
||
4131 | html: 'startTagHtml', |
||
4132 | head: 'startTagHead', |
||
4133 | title: 'startTagTitle', |
||
4134 | script: 'startTagScript', |
||
4135 | style: 'startTagNoFramesStyle', |
||
4136 | noscript: 'startTagNoScript', |
||
4137 | noframes: 'startTagNoFramesStyle', |
||
4138 | base: 'startTagBaseBasefontBgsoundLink', |
||
4139 | basefont: 'startTagBaseBasefontBgsoundLink', |
||
4140 | bgsound: 'startTagBaseBasefontBgsoundLink', |
||
4141 | link: 'startTagBaseBasefontBgsoundLink', |
||
4142 | meta: 'startTagMeta', |
||
4143 | "-default": 'startTagOther' |
||
4144 | }; |
||
4145 | |||
4146 | modes.inHead.end_tag_handlers = { |
||
4147 | head: 'endTagHead', |
||
4148 | html: 'endTagHtmlBodyBr', |
||
4149 | body: 'endTagHtmlBodyBr', |
||
4150 | br: 'endTagHtmlBodyBr', |
||
4151 | "-default": 'endTagOther' |
||
4152 | }; |
||
4153 | |||
4154 | modes.inHead.processEOF = function() { |
||
4155 | var name = tree.currentStackItem().localName; |
||
4156 | if (['title', 'style', 'script'].indexOf(name) != -1) { |
||
4157 | tree.parseError("expected-named-closing-tag-but-got-eof", {name: name}); |
||
4158 | tree.popElement(); |
||
4159 | } |
||
4160 | |||
4161 | this.anythingElse(); |
||
4162 | |||
4163 | tree.insertionMode.processEOF(); |
||
4164 | }; |
||
4165 | |||
4166 | modes.inHead.processCharacters = function(buffer) { |
||
4167 | var leadingWhitespace = buffer.takeLeadingWhitespace(); |
||
4168 | if (leadingWhitespace) |
||
4169 | tree.insertText(leadingWhitespace); |
||
4170 | if (!buffer.length) |
||
4171 | return; |
||
4172 | this.anythingElse(); |
||
4173 | tree.insertionMode.processCharacters(buffer); |
||
4174 | }; |
||
4175 | |||
4176 | modes.inHead.startTagHtml = function(name, attributes) { |
||
4177 | modes.inBody.processStartTag(name, attributes); |
||
4178 | }; |
||
4179 | |||
4180 | modes.inHead.startTagHead = function(name, attributes) { |
||
4181 | tree.parseError('two-heads-are-not-better-than-one'); |
||
4182 | }; |
||
4183 | |||
4184 | modes.inHead.startTagTitle = function(name, attributes) { |
||
4185 | tree.processGenericRCDATAStartTag(name, attributes); |
||
4186 | }; |
||
4187 | |||
4188 | modes.inHead.startTagNoScript = function(name, attributes) { |
||
4189 | if (tree.scriptingEnabled) |
||
4190 | return tree.processGenericRawTextStartTag(name, attributes); |
||
4191 | tree.insertElement(name, attributes); |
||
4192 | tree.setInsertionMode('inHeadNoscript'); |
||
4193 | }; |
||
4194 | |||
4195 | modes.inHead.startTagNoFramesStyle = function(name, attributes) { |
||
4196 | tree.processGenericRawTextStartTag(name, attributes); |
||
4197 | }; |
||
4198 | |||
4199 | modes.inHead.startTagScript = function(name, attributes) { |
||
4200 | tree.insertElement(name, attributes); |
||
4201 | tree.tokenizer.setState(Tokenizer.SCRIPT_DATA); |
||
4202 | tree.originalInsertionMode = tree.insertionModeName; |
||
4203 | tree.setInsertionMode('text'); |
||
4204 | }; |
||
4205 | |||
4206 | modes.inHead.startTagBaseBasefontBgsoundLink = function(name, attributes) { |
||
4207 | tree.insertSelfClosingElement(name, attributes); |
||
4208 | }; |
||
4209 | |||
4210 | modes.inHead.startTagMeta = function(name, attributes) { |
||
4211 | tree.insertSelfClosingElement(name, attributes); |
||
4212 | }; |
||
4213 | |||
4214 | modes.inHead.startTagOther = function(name, attributes, selfClosing) { |
||
4215 | this.anythingElse(); |
||
4216 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
4217 | }; |
||
4218 | |||
4219 | modes.inHead.endTagHead = function(name) { |
||
4220 | if (tree.openElements.item(tree.openElements.length - 1).localName == 'head') { |
||
4221 | tree.openElements.pop(); |
||
4222 | } else { |
||
4223 | tree.parseError('unexpected-end-tag', {name: 'head'}); |
||
4224 | } |
||
4225 | tree.setInsertionMode('afterHead'); |
||
4226 | }; |
||
4227 | |||
4228 | modes.inHead.endTagHtmlBodyBr = function(name) { |
||
4229 | this.anythingElse(); |
||
4230 | tree.insertionMode.processEndTag(name); |
||
4231 | }; |
||
4232 | |||
4233 | modes.inHead.endTagOther = function(name) { |
||
4234 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4235 | }; |
||
4236 | |||
4237 | modes.inHead.anythingElse = function() { |
||
4238 | this.endTagHead('head'); |
||
4239 | }; |
||
4240 | |||
4241 | modes.afterHead = Object.create(modes.base); |
||
4242 | |||
4243 | modes.afterHead.start_tag_handlers = { |
||
4244 | html: 'startTagHtml', |
||
4245 | head: 'startTagHead', |
||
4246 | body: 'startTagBody', |
||
4247 | frameset: 'startTagFrameset', |
||
4248 | base: 'startTagFromHead', |
||
4249 | link: 'startTagFromHead', |
||
4250 | meta: 'startTagFromHead', |
||
4251 | script: 'startTagFromHead', |
||
4252 | style: 'startTagFromHead', |
||
4253 | title: 'startTagFromHead', |
||
4254 | "-default": 'startTagOther' |
||
4255 | }; |
||
4256 | |||
4257 | modes.afterHead.end_tag_handlers = { |
||
4258 | body: 'endTagBodyHtmlBr', |
||
4259 | html: 'endTagBodyHtmlBr', |
||
4260 | br: 'endTagBodyHtmlBr', |
||
4261 | "-default": 'endTagOther' |
||
4262 | }; |
||
4263 | |||
4264 | modes.afterHead.processEOF = function() { |
||
4265 | this.anythingElse(); |
||
4266 | tree.insertionMode.processEOF(); |
||
4267 | }; |
||
4268 | |||
4269 | modes.afterHead.processCharacters = function(buffer) { |
||
4270 | var leadingWhitespace = buffer.takeLeadingWhitespace(); |
||
4271 | if (leadingWhitespace) |
||
4272 | tree.insertText(leadingWhitespace); |
||
4273 | if (!buffer.length) |
||
4274 | return; |
||
4275 | this.anythingElse(); |
||
4276 | tree.insertionMode.processCharacters(buffer); |
||
4277 | }; |
||
4278 | |||
4279 | modes.afterHead.startTagHtml = function(name, attributes) { |
||
4280 | modes.inBody.processStartTag(name, attributes); |
||
4281 | }; |
||
4282 | |||
4283 | modes.afterHead.startTagBody = function(name, attributes) { |
||
4284 | tree.framesetOk = false; |
||
4285 | tree.insertBodyElement(attributes); |
||
4286 | tree.setInsertionMode('inBody'); |
||
4287 | }; |
||
4288 | |||
4289 | modes.afterHead.startTagFrameset = function(name, attributes) { |
||
4290 | tree.insertElement(name, attributes); |
||
4291 | tree.setInsertionMode('inFrameset'); |
||
4292 | }; |
||
4293 | |||
4294 | modes.afterHead.startTagFromHead = function(name, attributes, selfClosing) { |
||
4295 | tree.parseError("unexpected-start-tag-out-of-my-head", {name: name}); |
||
4296 | tree.openElements.push(tree.head); |
||
4297 | modes.inHead.processStartTag(name, attributes, selfClosing); |
||
4298 | tree.openElements.remove(tree.head); |
||
4299 | }; |
||
4300 | |||
4301 | modes.afterHead.startTagHead = function(name, attributes, selfClosing) { |
||
4302 | tree.parseError('unexpected-start-tag', {name: name}); |
||
4303 | }; |
||
4304 | |||
4305 | modes.afterHead.startTagOther = function(name, attributes, selfClosing) { |
||
4306 | this.anythingElse(); |
||
4307 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
4308 | }; |
||
4309 | |||
4310 | modes.afterHead.endTagBodyHtmlBr = function(name) { |
||
4311 | this.anythingElse(); |
||
4312 | tree.insertionMode.processEndTag(name); |
||
4313 | }; |
||
4314 | |||
4315 | modes.afterHead.endTagOther = function(name) { |
||
4316 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4317 | }; |
||
4318 | |||
4319 | modes.afterHead.anythingElse = function() { |
||
4320 | tree.insertBodyElement([]); |
||
4321 | tree.setInsertionMode('inBody'); |
||
4322 | tree.framesetOk = true; |
||
4323 | } |
||
4324 | |||
4325 | modes.inBody = Object.create(modes.base); |
||
4326 | |||
4327 | modes.inBody.start_tag_handlers = { |
||
4328 | html: 'startTagHtml', |
||
4329 | head: 'startTagMisplaced', |
||
4330 | base: 'startTagProcessInHead', |
||
4331 | basefont: 'startTagProcessInHead', |
||
4332 | bgsound: 'startTagProcessInHead', |
||
4333 | link: 'startTagProcessInHead', |
||
4334 | meta: 'startTagProcessInHead', |
||
4335 | noframes: 'startTagProcessInHead', |
||
4336 | script: 'startTagProcessInHead', |
||
4337 | style: 'startTagProcessInHead', |
||
4338 | title: 'startTagProcessInHead', |
||
4339 | body: 'startTagBody', |
||
4340 | form: 'startTagForm', |
||
4341 | plaintext: 'startTagPlaintext', |
||
4342 | a: 'startTagA', |
||
4343 | button: 'startTagButton', |
||
4344 | xmp: 'startTagXmp', |
||
4345 | table: 'startTagTable', |
||
4346 | hr: 'startTagHr', |
||
4347 | image: 'startTagImage', |
||
4348 | input: 'startTagInput', |
||
4349 | textarea: 'startTagTextarea', |
||
4350 | select: 'startTagSelect', |
||
4351 | isindex: 'startTagIsindex', |
||
4352 | applet: 'startTagAppletMarqueeObject', |
||
4353 | marquee: 'startTagAppletMarqueeObject', |
||
4354 | object: 'startTagAppletMarqueeObject', |
||
4355 | li: 'startTagListItem', |
||
4356 | dd: 'startTagListItem', |
||
4357 | dt: 'startTagListItem', |
||
4358 | address: 'startTagCloseP', |
||
4359 | article: 'startTagCloseP', |
||
4360 | aside: 'startTagCloseP', |
||
4361 | blockquote: 'startTagCloseP', |
||
4362 | center: 'startTagCloseP', |
||
4363 | details: 'startTagCloseP', |
||
4364 | dir: 'startTagCloseP', |
||
4365 | div: 'startTagCloseP', |
||
4366 | dl: 'startTagCloseP', |
||
4367 | fieldset: 'startTagCloseP', |
||
4368 | figcaption: 'startTagCloseP', |
||
4369 | figure: 'startTagCloseP', |
||
4370 | footer: 'startTagCloseP', |
||
4371 | header: 'startTagCloseP', |
||
4372 | hgroup: 'startTagCloseP', |
||
4373 | main: 'startTagCloseP', |
||
4374 | menu: 'startTagCloseP', |
||
4375 | nav: 'startTagCloseP', |
||
4376 | ol: 'startTagCloseP', |
||
4377 | p: 'startTagCloseP', |
||
4378 | section: 'startTagCloseP', |
||
4379 | summary: 'startTagCloseP', |
||
4380 | ul: 'startTagCloseP', |
||
4381 | listing: 'startTagPreListing', |
||
4382 | pre: 'startTagPreListing', |
||
4383 | b: 'startTagFormatting', |
||
4384 | big: 'startTagFormatting', |
||
4385 | code: 'startTagFormatting', |
||
4386 | em: 'startTagFormatting', |
||
4387 | font: 'startTagFormatting', |
||
4388 | i: 'startTagFormatting', |
||
4389 | s: 'startTagFormatting', |
||
4390 | small: 'startTagFormatting', |
||
4391 | strike: 'startTagFormatting', |
||
4392 | strong: 'startTagFormatting', |
||
4393 | tt: 'startTagFormatting', |
||
4394 | u: 'startTagFormatting', |
||
4395 | nobr: 'startTagNobr', |
||
4396 | area: 'startTagVoidFormatting', |
||
4397 | br: 'startTagVoidFormatting', |
||
4398 | embed: 'startTagVoidFormatting', |
||
4399 | img: 'startTagVoidFormatting', |
||
4400 | keygen: 'startTagVoidFormatting', |
||
4401 | wbr: 'startTagVoidFormatting', |
||
4402 | param: 'startTagParamSourceTrack', |
||
4403 | source: 'startTagParamSourceTrack', |
||
4404 | track: 'startTagParamSourceTrack', |
||
4405 | iframe: 'startTagIFrame', |
||
4406 | noembed: 'startTagRawText', |
||
4407 | noscript: 'startTagRawText', |
||
4408 | h1: 'startTagHeading', |
||
4409 | h2: 'startTagHeading', |
||
4410 | h3: 'startTagHeading', |
||
4411 | h4: 'startTagHeading', |
||
4412 | h5: 'startTagHeading', |
||
4413 | h6: 'startTagHeading', |
||
4414 | caption: 'startTagMisplaced', |
||
4415 | col: 'startTagMisplaced', |
||
4416 | colgroup: 'startTagMisplaced', |
||
4417 | frame: 'startTagMisplaced', |
||
4418 | frameset: 'startTagFrameset', |
||
4419 | tbody: 'startTagMisplaced', |
||
4420 | td: 'startTagMisplaced', |
||
4421 | tfoot: 'startTagMisplaced', |
||
4422 | th: 'startTagMisplaced', |
||
4423 | thead: 'startTagMisplaced', |
||
4424 | tr: 'startTagMisplaced', |
||
4425 | option: 'startTagOptionOptgroup', |
||
4426 | optgroup: 'startTagOptionOptgroup', |
||
4427 | math: 'startTagMath', |
||
4428 | svg: 'startTagSVG', |
||
4429 | rt: 'startTagRpRt', |
||
4430 | rp: 'startTagRpRt', |
||
4431 | "-default": 'startTagOther' |
||
4432 | }; |
||
4433 | |||
4434 | modes.inBody.end_tag_handlers = { |
||
4435 | p: 'endTagP', |
||
4436 | body: 'endTagBody', |
||
4437 | html: 'endTagHtml', |
||
4438 | address: 'endTagBlock', |
||
4439 | article: 'endTagBlock', |
||
4440 | aside: 'endTagBlock', |
||
4441 | blockquote: 'endTagBlock', |
||
4442 | button: 'endTagBlock', |
||
4443 | center: 'endTagBlock', |
||
4444 | details: 'endTagBlock', |
||
4445 | dir: 'endTagBlock', |
||
4446 | div: 'endTagBlock', |
||
4447 | dl: 'endTagBlock', |
||
4448 | fieldset: 'endTagBlock', |
||
4449 | figcaption: 'endTagBlock', |
||
4450 | figure: 'endTagBlock', |
||
4451 | footer: 'endTagBlock', |
||
4452 | header: 'endTagBlock', |
||
4453 | hgroup: 'endTagBlock', |
||
4454 | listing: 'endTagBlock', |
||
4455 | main: 'endTagBlock', |
||
4456 | menu: 'endTagBlock', |
||
4457 | nav: 'endTagBlock', |
||
4458 | ol: 'endTagBlock', |
||
4459 | pre: 'endTagBlock', |
||
4460 | section: 'endTagBlock', |
||
4461 | summary: 'endTagBlock', |
||
4462 | ul: 'endTagBlock', |
||
4463 | form: 'endTagForm', |
||
4464 | applet: 'endTagAppletMarqueeObject', |
||
4465 | marquee: 'endTagAppletMarqueeObject', |
||
4466 | object: 'endTagAppletMarqueeObject', |
||
4467 | dd: 'endTagListItem', |
||
4468 | dt: 'endTagListItem', |
||
4469 | li: 'endTagListItem', |
||
4470 | h1: 'endTagHeading', |
||
4471 | h2: 'endTagHeading', |
||
4472 | h3: 'endTagHeading', |
||
4473 | h4: 'endTagHeading', |
||
4474 | h5: 'endTagHeading', |
||
4475 | h6: 'endTagHeading', |
||
4476 | a: 'endTagFormatting', |
||
4477 | b: 'endTagFormatting', |
||
4478 | big: 'endTagFormatting', |
||
4479 | code: 'endTagFormatting', |
||
4480 | em: 'endTagFormatting', |
||
4481 | font: 'endTagFormatting', |
||
4482 | i: 'endTagFormatting', |
||
4483 | nobr: 'endTagFormatting', |
||
4484 | s: 'endTagFormatting', |
||
4485 | small: 'endTagFormatting', |
||
4486 | strike: 'endTagFormatting', |
||
4487 | strong: 'endTagFormatting', |
||
4488 | tt: 'endTagFormatting', |
||
4489 | u: 'endTagFormatting', |
||
4490 | br: 'endTagBr', |
||
4491 | "-default": 'endTagOther' |
||
4492 | }; |
||
4493 | |||
4494 | modes.inBody.processCharacters = function(buffer) { |
||
4495 | if (tree.shouldSkipLeadingNewline) { |
||
4496 | tree.shouldSkipLeadingNewline = false; |
||
4497 | buffer.skipAtMostOneLeadingNewline(); |
||
4498 | } |
||
4499 | tree.reconstructActiveFormattingElements(); |
||
4500 | var characters = buffer.takeRemaining(); |
||
4501 | characters = characters.replace(/\u0000/g, function(match, index){ |
||
4502 | tree.parseError("invalid-codepoint"); |
||
4503 | return ''; |
||
4504 | }); |
||
4505 | if (!characters) |
||
4506 | return; |
||
4507 | tree.insertText(characters); |
||
4508 | if (tree.framesetOk && !isAllWhitespaceOrReplacementCharacters(characters)) |
||
4509 | tree.framesetOk = false; |
||
4510 | }; |
||
4511 | |||
4512 | modes.inBody.startTagHtml = function(name, attributes) { |
||
4513 | tree.parseError('non-html-root'); |
||
4514 | tree.addAttributesToElement(tree.openElements.rootNode, attributes); |
||
4515 | }; |
||
4516 | |||
4517 | modes.inBody.startTagProcessInHead = function(name, attributes) { |
||
4518 | modes.inHead.processStartTag(name, attributes); |
||
4519 | }; |
||
4520 | |||
4521 | modes.inBody.startTagBody = function(name, attributes) { |
||
4522 | tree.parseError('unexpected-start-tag', {name: 'body'}); |
||
4523 | if (tree.openElements.length == 1 || |
||
4524 | tree.openElements.item(1).localName != 'body') { |
||
4525 | assert.ok(tree.context); |
||
4526 | } else { |
||
4527 | tree.framesetOk = false; |
||
4528 | tree.addAttributesToElement(tree.openElements.bodyElement, attributes); |
||
4529 | } |
||
4530 | }; |
||
4531 | |||
4532 | modes.inBody.startTagFrameset = function(name, attributes) { |
||
4533 | tree.parseError('unexpected-start-tag', {name: 'frameset'}); |
||
4534 | if (tree.openElements.length == 1 || |
||
4535 | tree.openElements.item(1).localName != 'body') { |
||
4536 | assert.ok(tree.context); |
||
4537 | } else if (tree.framesetOk) { |
||
4538 | tree.detachFromParent(tree.openElements.bodyElement); |
||
4539 | while (tree.openElements.length > 1) |
||
4540 | tree.openElements.pop(); |
||
4541 | tree.insertElement(name, attributes); |
||
4542 | tree.setInsertionMode('inFrameset'); |
||
4543 | } |
||
4544 | }; |
||
4545 | |||
4546 | modes.inBody.startTagCloseP = function(name, attributes) { |
||
4547 | if (tree.openElements.inButtonScope('p')) |
||
4548 | this.endTagP('p'); |
||
4549 | tree.insertElement(name, attributes); |
||
4550 | }; |
||
4551 | |||
4552 | modes.inBody.startTagPreListing = function(name, attributes) { |
||
4553 | if (tree.openElements.inButtonScope('p')) |
||
4554 | this.endTagP('p'); |
||
4555 | tree.insertElement(name, attributes); |
||
4556 | tree.framesetOk = false; |
||
4557 | tree.shouldSkipLeadingNewline = true; |
||
4558 | }; |
||
4559 | |||
4560 | modes.inBody.startTagForm = function(name, attributes) { |
||
4561 | if (tree.form) { |
||
4562 | tree.parseError('unexpected-start-tag', {name: name}); |
||
4563 | } else { |
||
4564 | if (tree.openElements.inButtonScope('p')) |
||
4565 | this.endTagP('p'); |
||
4566 | tree.insertElement(name, attributes); |
||
4567 | tree.form = tree.currentStackItem(); |
||
4568 | } |
||
4569 | }; |
||
4570 | |||
4571 | modes.inBody.startTagRpRt = function(name, attributes) { |
||
4572 | if (tree.openElements.inScope('ruby')) { |
||
4573 | tree.generateImpliedEndTags(); |
||
4574 | if (tree.currentStackItem().localName != 'ruby') { |
||
4575 | tree.parseError('unexpected-start-tag', {name: name}); |
||
4576 | } |
||
4577 | } |
||
4578 | tree.insertElement(name, attributes); |
||
4579 | }; |
||
4580 | |||
4581 | modes.inBody.startTagListItem = function(name, attributes) { |
||
4582 | var stopNames = {li: ['li'], dd: ['dd', 'dt'], dt: ['dd', 'dt']}; |
||
4583 | var stopName = stopNames[name]; |
||
4584 | |||
4585 | var els = tree.openElements; |
||
4586 | for (var i = els.length - 1; i >= 0; i--) { |
||
4587 | var node = els.item(i); |
||
4588 | if (stopName.indexOf(node.localName) != -1) { |
||
4589 | tree.insertionMode.processEndTag(node.localName); |
||
4590 | break; |
||
4591 | } |
||
4592 | if (node.isSpecial() && node.localName !== 'p' && node.localName !== 'address' && node.localName !== 'div') |
||
4593 | break; |
||
4594 | } |
||
4595 | if (tree.openElements.inButtonScope('p')) |
||
4596 | this.endTagP('p'); |
||
4597 | tree.insertElement(name, attributes); |
||
4598 | tree.framesetOk = false; |
||
4599 | }; |
||
4600 | |||
4601 | modes.inBody.startTagPlaintext = function(name, attributes) { |
||
4602 | if (tree.openElements.inButtonScope('p')) |
||
4603 | this.endTagP('p'); |
||
4604 | tree.insertElement(name, attributes); |
||
4605 | tree.tokenizer.setState(Tokenizer.PLAINTEXT); |
||
4606 | }; |
||
4607 | |||
4608 | modes.inBody.startTagHeading = function(name, attributes) { |
||
4609 | if (tree.openElements.inButtonScope('p')) |
||
4610 | this.endTagP('p'); |
||
4611 | if (tree.currentStackItem().isNumberedHeader()) { |
||
4612 | tree.parseError('unexpected-start-tag', {name: name}); |
||
4613 | tree.popElement(); |
||
4614 | } |
||
4615 | tree.insertElement(name, attributes); |
||
4616 | }; |
||
4617 | |||
4618 | modes.inBody.startTagA = function(name, attributes) { |
||
4619 | var activeA = tree.elementInActiveFormattingElements('a'); |
||
4620 | if (activeA) { |
||
4621 | tree.parseError("unexpected-start-tag-implies-end-tag", {startName: "a", endName: "a"}); |
||
4622 | tree.adoptionAgencyEndTag('a'); |
||
4623 | if (tree.openElements.contains(activeA)) |
||
4624 | tree.openElements.remove(activeA); |
||
4625 | tree.removeElementFromActiveFormattingElements(activeA); |
||
4626 | } |
||
4627 | tree.reconstructActiveFormattingElements(); |
||
4628 | tree.insertFormattingElement(name, attributes); |
||
4629 | }; |
||
4630 | |||
4631 | modes.inBody.startTagFormatting = function(name, attributes) { |
||
4632 | tree.reconstructActiveFormattingElements(); |
||
4633 | tree.insertFormattingElement(name, attributes); |
||
4634 | }; |
||
4635 | |||
4636 | modes.inBody.startTagNobr = function(name, attributes) { |
||
4637 | tree.reconstructActiveFormattingElements(); |
||
4638 | if (tree.openElements.inScope('nobr')) { |
||
4639 | tree.parseError("unexpected-start-tag-implies-end-tag", {startName: 'nobr', endName: 'nobr'}); |
||
4640 | this.processEndTag('nobr'); |
||
4641 | tree.reconstructActiveFormattingElements(); |
||
4642 | } |
||
4643 | tree.insertFormattingElement(name, attributes); |
||
4644 | }; |
||
4645 | |||
4646 | modes.inBody.startTagButton = function(name, attributes) { |
||
4647 | if (tree.openElements.inScope('button')) { |
||
4648 | tree.parseError('unexpected-start-tag-implies-end-tag', {startName: 'button', endName: 'button'}); |
||
4649 | this.processEndTag('button'); |
||
4650 | tree.insertionMode.processStartTag(name, attributes); |
||
4651 | } else { |
||
4652 | tree.framesetOk = false; |
||
4653 | tree.reconstructActiveFormattingElements(); |
||
4654 | tree.insertElement(name, attributes); |
||
4655 | } |
||
4656 | }; |
||
4657 | |||
4658 | modes.inBody.startTagAppletMarqueeObject = function(name, attributes) { |
||
4659 | tree.reconstructActiveFormattingElements(); |
||
4660 | tree.insertElement(name, attributes); |
||
4661 | tree.activeFormattingElements.push(Marker); |
||
4662 | tree.framesetOk = false; |
||
4663 | }; |
||
4664 | |||
4665 | modes.inBody.endTagAppletMarqueeObject = function(name) { |
||
4666 | if (!tree.openElements.inScope(name)) { |
||
4667 | tree.parseError("unexpected-end-tag", {name: name}); |
||
4668 | } else { |
||
4669 | tree.generateImpliedEndTags(); |
||
4670 | if (tree.currentStackItem().localName != name) { |
||
4671 | tree.parseError('end-tag-too-early', {name: name}); |
||
4672 | } |
||
4673 | tree.openElements.popUntilPopped(name); |
||
4674 | tree.clearActiveFormattingElements(); |
||
4675 | } |
||
4676 | }; |
||
4677 | |||
4678 | modes.inBody.startTagXmp = function(name, attributes) { |
||
4679 | if (tree.openElements.inButtonScope('p')) |
||
4680 | this.processEndTag('p'); |
||
4681 | tree.reconstructActiveFormattingElements(); |
||
4682 | tree.processGenericRawTextStartTag(name, attributes); |
||
4683 | tree.framesetOk = false; |
||
4684 | }; |
||
4685 | |||
4686 | modes.inBody.startTagTable = function(name, attributes) { |
||
4687 | if (tree.compatMode !== "quirks") |
||
4688 | if (tree.openElements.inButtonScope('p')) |
||
4689 | this.processEndTag('p'); |
||
4690 | tree.insertElement(name, attributes); |
||
4691 | tree.setInsertionMode('inTable'); |
||
4692 | tree.framesetOk = false; |
||
4693 | }; |
||
4694 | |||
4695 | modes.inBody.startTagVoidFormatting = function(name, attributes) { |
||
4696 | tree.reconstructActiveFormattingElements(); |
||
4697 | tree.insertSelfClosingElement(name, attributes); |
||
4698 | tree.framesetOk = false; |
||
4699 | }; |
||
4700 | |||
4701 | modes.inBody.startTagParamSourceTrack = function(name, attributes) { |
||
4702 | tree.insertSelfClosingElement(name, attributes); |
||
4703 | }; |
||
4704 | |||
4705 | modes.inBody.startTagHr = function(name, attributes) { |
||
4706 | if (tree.openElements.inButtonScope('p')) |
||
4707 | this.endTagP('p'); |
||
4708 | tree.insertSelfClosingElement(name, attributes); |
||
4709 | tree.framesetOk = false; |
||
4710 | }; |
||
4711 | |||
4712 | modes.inBody.startTagImage = function(name, attributes) { |
||
4713 | tree.parseError('unexpected-start-tag-treated-as', {originalName: 'image', newName: 'img'}); |
||
4714 | this.processStartTag('img', attributes); |
||
4715 | }; |
||
4716 | |||
4717 | modes.inBody.startTagInput = function(name, attributes) { |
||
4718 | var currentFramesetOk = tree.framesetOk; |
||
4719 | this.startTagVoidFormatting(name, attributes); |
||
4720 | for (var key in attributes) { |
||
4721 | if (attributes[key].nodeName == 'type') { |
||
4722 | if (attributes[key].nodeValue.toLowerCase() == 'hidden') |
||
4723 | tree.framesetOk = currentFramesetOk; |
||
4724 | break; |
||
4725 | } |
||
4726 | } |
||
4727 | }; |
||
4728 | |||
4729 | modes.inBody.startTagIsindex = function(name, attributes) { |
||
4730 | tree.parseError('deprecated-tag', {name: 'isindex'}); |
||
4731 | tree.selfClosingFlagAcknowledged = true; |
||
4732 | if (tree.form) |
||
4733 | return; |
||
4734 | var formAttributes = []; |
||
4735 | var inputAttributes = []; |
||
4736 | var prompt = "This is a searchable index. Enter search keywords: "; |
||
4737 | for (var key in attributes) { |
||
4738 | switch (attributes[key].nodeName) { |
||
4739 | case 'action': |
||
4740 | formAttributes.push({nodeName: 'action', |
||
4741 | nodeValue: attributes[key].nodeValue}); |
||
4742 | break; |
||
4743 | case 'prompt': |
||
4744 | prompt = attributes[key].nodeValue; |
||
4745 | break; |
||
4746 | case 'name': |
||
4747 | break; |
||
4748 | default: |
||
4749 | inputAttributes.push({nodeName: attributes[key].nodeName, |
||
4750 | nodeValue: attributes[key].nodeValue}); |
||
4751 | } |
||
4752 | } |
||
4753 | inputAttributes.push({nodeName: 'name', nodeValue: 'isindex'}); |
||
4754 | this.processStartTag('form', formAttributes); |
||
4755 | this.processStartTag('hr'); |
||
4756 | this.processStartTag('label'); |
||
4757 | this.processCharacters(new CharacterBuffer(prompt)); |
||
4758 | this.processStartTag('input', inputAttributes); |
||
4759 | this.processEndTag('label'); |
||
4760 | this.processStartTag('hr'); |
||
4761 | this.processEndTag('form'); |
||
4762 | }; |
||
4763 | |||
4764 | modes.inBody.startTagTextarea = function(name, attributes) { |
||
4765 | tree.insertElement(name, attributes); |
||
4766 | tree.tokenizer.setState(Tokenizer.RCDATA); |
||
4767 | tree.originalInsertionMode = tree.insertionModeName; |
||
4768 | tree.shouldSkipLeadingNewline = true; |
||
4769 | tree.framesetOk = false; |
||
4770 | tree.setInsertionMode('text'); |
||
4771 | }; |
||
4772 | |||
4773 | modes.inBody.startTagIFrame = function(name, attributes) { |
||
4774 | tree.framesetOk = false; |
||
4775 | this.startTagRawText(name, attributes); |
||
4776 | }; |
||
4777 | |||
4778 | modes.inBody.startTagRawText = function(name, attributes) { |
||
4779 | tree.processGenericRawTextStartTag(name, attributes); |
||
4780 | }; |
||
4781 | |||
4782 | modes.inBody.startTagSelect = function(name, attributes) { |
||
4783 | tree.reconstructActiveFormattingElements(); |
||
4784 | tree.insertElement(name, attributes); |
||
4785 | tree.framesetOk = false; |
||
4786 | var insertionModeName = tree.insertionModeName; |
||
4787 | if (insertionModeName == 'inTable' || |
||
4788 | insertionModeName == 'inCaption' || |
||
4789 | insertionModeName == 'inColumnGroup' || |
||
4790 | insertionModeName == 'inTableBody' || |
||
4791 | insertionModeName == 'inRow' || |
||
4792 | insertionModeName == 'inCell') { |
||
4793 | tree.setInsertionMode('inSelectInTable'); |
||
4794 | } else { |
||
4795 | tree.setInsertionMode('inSelect'); |
||
4796 | } |
||
4797 | }; |
||
4798 | |||
4799 | modes.inBody.startTagMisplaced = function(name, attributes) { |
||
4800 | tree.parseError('unexpected-start-tag-ignored', {name: name}); |
||
4801 | }; |
||
4802 | |||
4803 | modes.inBody.endTagMisplaced = function(name) { |
||
4804 | tree.parseError("unexpected-end-tag", {name: name}); |
||
4805 | }; |
||
4806 | |||
4807 | modes.inBody.endTagBr = function(name) { |
||
4808 | tree.parseError("unexpected-end-tag-treated-as", {originalName: "br", newName: "br element"}); |
||
4809 | tree.reconstructActiveFormattingElements(); |
||
4810 | tree.insertElement(name, []); |
||
4811 | tree.popElement(); |
||
4812 | }; |
||
4813 | |||
4814 | modes.inBody.startTagOptionOptgroup = function(name, attributes) { |
||
4815 | if (tree.currentStackItem().localName == 'option') |
||
4816 | tree.popElement(); |
||
4817 | tree.reconstructActiveFormattingElements(); |
||
4818 | tree.insertElement(name, attributes); |
||
4819 | }; |
||
4820 | |||
4821 | modes.inBody.startTagOther = function(name, attributes) { |
||
4822 | tree.reconstructActiveFormattingElements(); |
||
4823 | tree.insertElement(name, attributes); |
||
4824 | }; |
||
4825 | |||
4826 | modes.inBody.endTagOther = function(name) { |
||
4827 | var node; |
||
4828 | for (var i = tree.openElements.length - 1; i > 0; i--) { |
||
4829 | node = tree.openElements.item(i); |
||
4830 | if (node.localName == name) { |
||
4831 | tree.generateImpliedEndTags(name); |
||
4832 | if (tree.currentStackItem().localName != name) |
||
4833 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4834 | tree.openElements.remove_openElements_until(function(x) {return x === node;}); |
||
4835 | break; |
||
4836 | } |
||
4837 | if (node.isSpecial()) { |
||
4838 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4839 | break; |
||
4840 | } |
||
4841 | } |
||
4842 | }; |
||
4843 | |||
4844 | modes.inBody.startTagMath = function(name, attributes, selfClosing) { |
||
4845 | tree.reconstructActiveFormattingElements(); |
||
4846 | attributes = tree.adjustMathMLAttributes(attributes); |
||
4847 | attributes = tree.adjustForeignAttributes(attributes); |
||
4848 | tree.insertForeignElement(name, attributes, "http://www.w3.org/1998/Math/MathML", selfClosing); |
||
4849 | }; |
||
4850 | |||
4851 | modes.inBody.startTagSVG = function(name, attributes, selfClosing) { |
||
4852 | tree.reconstructActiveFormattingElements(); |
||
4853 | attributes = tree.adjustSVGAttributes(attributes); |
||
4854 | attributes = tree.adjustForeignAttributes(attributes); |
||
4855 | tree.insertForeignElement(name, attributes, "http://www.w3.org/2000/svg", selfClosing); |
||
4856 | }; |
||
4857 | |||
4858 | modes.inBody.endTagP = function(name) { |
||
4859 | if (!tree.openElements.inButtonScope('p')) { |
||
4860 | tree.parseError('unexpected-end-tag', {name: 'p'}); |
||
4861 | this.startTagCloseP('p', []); |
||
4862 | this.endTagP('p'); |
||
4863 | } else { |
||
4864 | tree.generateImpliedEndTags('p'); |
||
4865 | if (tree.currentStackItem().localName != 'p') |
||
4866 | tree.parseError('unexpected-implied-end-tag', {name: 'p'}); |
||
4867 | tree.openElements.popUntilPopped(name); |
||
4868 | } |
||
4869 | }; |
||
4870 | |||
4871 | modes.inBody.endTagBody = function(name) { |
||
4872 | if (!tree.openElements.inScope('body')) { |
||
4873 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4874 | return; |
||
4875 | } |
||
4876 | if (tree.currentStackItem().localName != 'body') { |
||
4877 | tree.parseError('expected-one-end-tag-but-got-another', { |
||
4878 | expectedName: tree.currentStackItem().localName, |
||
4879 | gotName: name |
||
4880 | }); |
||
4881 | } |
||
4882 | tree.setInsertionMode('afterBody'); |
||
4883 | }; |
||
4884 | |||
4885 | modes.inBody.endTagHtml = 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 | tree.insertionMode.processEndTag(name); |
||
4898 | }; |
||
4899 | |||
4900 | modes.inBody.endTagBlock = function(name) { |
||
4901 | if (!tree.openElements.inScope(name)) { |
||
4902 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4903 | } else { |
||
4904 | tree.generateImpliedEndTags(); |
||
4905 | if (tree.currentStackItem().localName != name) { |
||
4906 | tree.parseError('end-tag-too-early', {name: name}); |
||
4907 | } |
||
4908 | tree.openElements.popUntilPopped(name); |
||
4909 | } |
||
4910 | }; |
||
4911 | |||
4912 | modes.inBody.endTagForm = function(name) { |
||
4913 | var node = tree.form; |
||
4914 | tree.form = null; |
||
4915 | if (!node || !tree.openElements.inScope(name)) { |
||
4916 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4917 | } else { |
||
4918 | tree.generateImpliedEndTags(); |
||
4919 | if (tree.currentStackItem() != node) { |
||
4920 | tree.parseError('end-tag-too-early-ignored', {name: 'form'}); |
||
4921 | } |
||
4922 | tree.openElements.remove(node); |
||
4923 | } |
||
4924 | }; |
||
4925 | |||
4926 | modes.inBody.endTagListItem = function(name) { |
||
4927 | if (!tree.openElements.inListItemScope(name)) { |
||
4928 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4929 | } else { |
||
4930 | tree.generateImpliedEndTags(name); |
||
4931 | if (tree.currentStackItem().localName != name) |
||
4932 | tree.parseError('end-tag-too-early', {name: name}); |
||
4933 | tree.openElements.popUntilPopped(name); |
||
4934 | } |
||
4935 | }; |
||
4936 | |||
4937 | modes.inBody.endTagHeading = function(name) { |
||
4938 | if (!tree.openElements.hasNumberedHeaderElementInScope()) { |
||
4939 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4940 | return; |
||
4941 | } |
||
4942 | tree.generateImpliedEndTags(); |
||
4943 | if (tree.currentStackItem().localName != name) |
||
4944 | tree.parseError('end-tag-too-early', {name: name}); |
||
4945 | |||
4946 | tree.openElements.remove_openElements_until(function(e) { |
||
4947 | return e.isNumberedHeader(); |
||
4948 | }); |
||
4949 | }; |
||
4950 | |||
4951 | modes.inBody.endTagFormatting = function(name, attributes) { |
||
4952 | if (!tree.adoptionAgencyEndTag(name)) |
||
4953 | this.endTagOther(name, attributes); |
||
4954 | }; |
||
4955 | |||
4956 | modes.inCaption = Object.create(modes.base); |
||
4957 | |||
4958 | modes.inCaption.start_tag_handlers = { |
||
4959 | html: 'startTagHtml', |
||
4960 | caption: 'startTagTableElement', |
||
4961 | col: 'startTagTableElement', |
||
4962 | colgroup: 'startTagTableElement', |
||
4963 | tbody: 'startTagTableElement', |
||
4964 | td: 'startTagTableElement', |
||
4965 | tfoot: 'startTagTableElement', |
||
4966 | thead: 'startTagTableElement', |
||
4967 | tr: 'startTagTableElement', |
||
4968 | '-default': 'startTagOther' |
||
4969 | }; |
||
4970 | |||
4971 | modes.inCaption.end_tag_handlers = { |
||
4972 | caption: 'endTagCaption', |
||
4973 | table: 'endTagTable', |
||
4974 | body: 'endTagIgnore', |
||
4975 | col: 'endTagIgnore', |
||
4976 | colgroup: 'endTagIgnore', |
||
4977 | html: 'endTagIgnore', |
||
4978 | tbody: 'endTagIgnore', |
||
4979 | td: 'endTagIgnore', |
||
4980 | tfood: 'endTagIgnore', |
||
4981 | thead: 'endTagIgnore', |
||
4982 | tr: 'endTagIgnore', |
||
4983 | '-default': 'endTagOther' |
||
4984 | }; |
||
4985 | |||
4986 | modes.inCaption.processCharacters = function(data) { |
||
4987 | modes.inBody.processCharacters(data); |
||
4988 | }; |
||
4989 | |||
4990 | modes.inCaption.startTagTableElement = function(name, attributes) { |
||
4991 | tree.parseError('unexpected-end-tag', {name: name}); |
||
4992 | var ignoreEndTag = !tree.openElements.inTableScope('caption'); |
||
4993 | tree.insertionMode.processEndTag('caption'); |
||
4994 | if (!ignoreEndTag) tree.insertionMode.processStartTag(name, attributes); |
||
4995 | }; |
||
4996 | |||
4997 | modes.inCaption.startTagOther = function(name, attributes, selfClosing) { |
||
4998 | modes.inBody.processStartTag(name, attributes, selfClosing); |
||
4999 | }; |
||
5000 | |||
5001 | modes.inCaption.endTagCaption = function(name) { |
||
5002 | if (!tree.openElements.inTableScope('caption')) { |
||
5003 | assert.ok(tree.context); |
||
5004 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5005 | } else { |
||
5006 | tree.generateImpliedEndTags(); |
||
5007 | if (tree.currentStackItem().localName != 'caption') { |
||
5008 | tree.parseError('expected-one-end-tag-but-got-another', { |
||
5009 | gotName: "caption", |
||
5010 | expectedName: tree.currentStackItem().localName |
||
5011 | }); |
||
5012 | } |
||
5013 | tree.openElements.popUntilPopped('caption'); |
||
5014 | tree.clearActiveFormattingElements(); |
||
5015 | tree.setInsertionMode('inTable'); |
||
5016 | } |
||
5017 | }; |
||
5018 | |||
5019 | modes.inCaption.endTagTable = function(name) { |
||
5020 | tree.parseError("unexpected-end-table-in-caption"); |
||
5021 | var ignoreEndTag = !tree.openElements.inTableScope('caption'); |
||
5022 | tree.insertionMode.processEndTag('caption'); |
||
5023 | if (!ignoreEndTag) tree.insertionMode.processEndTag(name); |
||
5024 | }; |
||
5025 | |||
5026 | modes.inCaption.endTagIgnore = function(name) { |
||
5027 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5028 | }; |
||
5029 | |||
5030 | modes.inCaption.endTagOther = function(name) { |
||
5031 | modes.inBody.processEndTag(name); |
||
5032 | }; |
||
5033 | |||
5034 | modes.inCell = Object.create(modes.base); |
||
5035 | |||
5036 | modes.inCell.start_tag_handlers = { |
||
5037 | html: 'startTagHtml', |
||
5038 | caption: 'startTagTableOther', |
||
5039 | col: 'startTagTableOther', |
||
5040 | colgroup: 'startTagTableOther', |
||
5041 | tbody: 'startTagTableOther', |
||
5042 | td: 'startTagTableOther', |
||
5043 | tfoot: 'startTagTableOther', |
||
5044 | th: 'startTagTableOther', |
||
5045 | thead: 'startTagTableOther', |
||
5046 | tr: 'startTagTableOther', |
||
5047 | '-default': 'startTagOther' |
||
5048 | }; |
||
5049 | |||
5050 | modes.inCell.end_tag_handlers = { |
||
5051 | td: 'endTagTableCell', |
||
5052 | th: 'endTagTableCell', |
||
5053 | body: 'endTagIgnore', |
||
5054 | caption: 'endTagIgnore', |
||
5055 | col: 'endTagIgnore', |
||
5056 | colgroup: 'endTagIgnore', |
||
5057 | html: 'endTagIgnore', |
||
5058 | table: 'endTagImply', |
||
5059 | tbody: 'endTagImply', |
||
5060 | tfoot: 'endTagImply', |
||
5061 | thead: 'endTagImply', |
||
5062 | tr: 'endTagImply', |
||
5063 | '-default': 'endTagOther' |
||
5064 | }; |
||
5065 | |||
5066 | modes.inCell.processCharacters = function(data) { |
||
5067 | modes.inBody.processCharacters(data); |
||
5068 | }; |
||
5069 | |||
5070 | modes.inCell.startTagTableOther = function(name, attributes, selfClosing) { |
||
5071 | if (tree.openElements.inTableScope('td') || tree.openElements.inTableScope('th')) { |
||
5072 | this.closeCell(); |
||
5073 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
5074 | } else { |
||
5075 | tree.parseError('unexpected-start-tag', {name: name}); |
||
5076 | } |
||
5077 | }; |
||
5078 | |||
5079 | modes.inCell.startTagOther = function(name, attributes, selfClosing) { |
||
5080 | modes.inBody.processStartTag(name, attributes, selfClosing); |
||
5081 | }; |
||
5082 | |||
5083 | modes.inCell.endTagTableCell = function(name) { |
||
5084 | if (tree.openElements.inTableScope(name)) { |
||
5085 | tree.generateImpliedEndTags(name); |
||
5086 | if (tree.currentStackItem().localName != name.toLowerCase()) { |
||
5087 | tree.parseError('unexpected-cell-end-tag', {name: name}); |
||
5088 | tree.openElements.popUntilPopped(name); |
||
5089 | } else { |
||
5090 | tree.popElement(); |
||
5091 | } |
||
5092 | tree.clearActiveFormattingElements(); |
||
5093 | tree.setInsertionMode('inRow'); |
||
5094 | } else { |
||
5095 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5096 | } |
||
5097 | }; |
||
5098 | |||
5099 | modes.inCell.endTagIgnore = function(name) { |
||
5100 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5101 | }; |
||
5102 | |||
5103 | modes.inCell.endTagImply = function(name) { |
||
5104 | if (tree.openElements.inTableScope(name)) { |
||
5105 | this.closeCell(); |
||
5106 | tree.insertionMode.processEndTag(name); |
||
5107 | } else { |
||
5108 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5109 | } |
||
5110 | }; |
||
5111 | |||
5112 | modes.inCell.endTagOther = function(name) { |
||
5113 | modes.inBody.processEndTag(name); |
||
5114 | }; |
||
5115 | |||
5116 | modes.inCell.closeCell = function() { |
||
5117 | if (tree.openElements.inTableScope('td')) { |
||
5118 | this.endTagTableCell('td'); |
||
5119 | } else if (tree.openElements.inTableScope('th')) { |
||
5120 | this.endTagTableCell('th'); |
||
5121 | } |
||
5122 | }; |
||
5123 | |||
5124 | |||
5125 | modes.inColumnGroup = Object.create(modes.base); |
||
5126 | |||
5127 | modes.inColumnGroup.start_tag_handlers = { |
||
5128 | html: 'startTagHtml', |
||
5129 | col: 'startTagCol', |
||
5130 | '-default': 'startTagOther' |
||
5131 | }; |
||
5132 | |||
5133 | modes.inColumnGroup.end_tag_handlers = { |
||
5134 | colgroup: 'endTagColgroup', |
||
5135 | col: 'endTagCol', |
||
5136 | '-default': 'endTagOther' |
||
5137 | }; |
||
5138 | |||
5139 | modes.inColumnGroup.ignoreEndTagColgroup = function() { |
||
5140 | return tree.currentStackItem().localName == 'html'; |
||
5141 | }; |
||
5142 | |||
5143 | modes.inColumnGroup.processCharacters = function(buffer) { |
||
5144 | var leadingWhitespace = buffer.takeLeadingWhitespace(); |
||
5145 | if (leadingWhitespace) |
||
5146 | tree.insertText(leadingWhitespace); |
||
5147 | if (!buffer.length) |
||
5148 | return; |
||
5149 | var ignoreEndTag = this.ignoreEndTagColgroup(); |
||
5150 | this.endTagColgroup('colgroup'); |
||
5151 | if (!ignoreEndTag) tree.insertionMode.processCharacters(buffer); |
||
5152 | }; |
||
5153 | |||
5154 | modes.inColumnGroup.startTagCol = function(name, attributes) { |
||
5155 | tree.insertSelfClosingElement(name, attributes); |
||
5156 | }; |
||
5157 | |||
5158 | modes.inColumnGroup.startTagOther = function(name, attributes, selfClosing) { |
||
5159 | var ignoreEndTag = this.ignoreEndTagColgroup(); |
||
5160 | this.endTagColgroup('colgroup'); |
||
5161 | if (!ignoreEndTag) tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
5162 | }; |
||
5163 | |||
5164 | modes.inColumnGroup.endTagColgroup = function(name) { |
||
5165 | if (this.ignoreEndTagColgroup()) { |
||
5166 | assert.ok(tree.context); |
||
5167 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5168 | } else { |
||
5169 | tree.popElement(); |
||
5170 | tree.setInsertionMode('inTable'); |
||
5171 | } |
||
5172 | }; |
||
5173 | |||
5174 | modes.inColumnGroup.endTagCol = function(name) { |
||
5175 | tree.parseError("no-end-tag", {name: 'col'}); |
||
5176 | }; |
||
5177 | |||
5178 | modes.inColumnGroup.endTagOther = function(name) { |
||
5179 | var ignoreEndTag = this.ignoreEndTagColgroup(); |
||
5180 | this.endTagColgroup('colgroup'); |
||
5181 | if (!ignoreEndTag) tree.insertionMode.processEndTag(name) ; |
||
5182 | }; |
||
5183 | |||
5184 | modes.inForeignContent = Object.create(modes.base); |
||
5185 | |||
5186 | modes.inForeignContent.processStartTag = function(name, attributes, selfClosing) { |
||
5187 | 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 |
||
5188 | || (name == 'font' && attributes.some(function(attr){ return ['color', 'face', 'size'].indexOf(attr.nodeName) >= 0 }))) { |
||
5189 | tree.parseError('unexpected-html-element-in-foreign-content', {name: name}); |
||
5190 | while (tree.currentStackItem().isForeign() |
||
5191 | && !tree.currentStackItem().isHtmlIntegrationPoint() |
||
5192 | && !tree.currentStackItem().isMathMLTextIntegrationPoint()) { |
||
5193 | tree.openElements.pop(); |
||
5194 | } |
||
5195 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
5196 | return; |
||
5197 | } |
||
5198 | if (tree.currentStackItem().namespaceURI == "http://www.w3.org/1998/Math/MathML") { |
||
5199 | attributes = tree.adjustMathMLAttributes(attributes); |
||
5200 | } |
||
5201 | if (tree.currentStackItem().namespaceURI == "http://www.w3.org/2000/svg") { |
||
5202 | name = tree.adjustSVGTagNameCase(name); |
||
5203 | attributes = tree.adjustSVGAttributes(attributes); |
||
5204 | } |
||
5205 | attributes = tree.adjustForeignAttributes(attributes); |
||
5206 | tree.insertForeignElement(name, attributes, tree.currentStackItem().namespaceURI, selfClosing); |
||
5207 | }; |
||
5208 | |||
5209 | modes.inForeignContent.processEndTag = function(name) { |
||
5210 | var node = tree.currentStackItem(); |
||
5211 | var index = tree.openElements.length - 1; |
||
5212 | if (node.localName.toLowerCase() != name) |
||
5213 | tree.parseError("unexpected-end-tag", {name: name}); |
||
5214 | |||
5215 | while (true) { |
||
5216 | if (index === 0) |
||
5217 | break; |
||
5218 | if (node.localName.toLowerCase() == name) { |
||
5219 | while (tree.openElements.pop() != node); |
||
5220 | break; |
||
5221 | } |
||
5222 | index -= 1; |
||
5223 | node = tree.openElements.item(index); |
||
5224 | if (node.isForeign()) { |
||
5225 | continue; |
||
5226 | } else { |
||
5227 | tree.insertionMode.processEndTag(name); |
||
5228 | break; |
||
5229 | } |
||
5230 | } |
||
5231 | }; |
||
5232 | |||
5233 | modes.inForeignContent.processCharacters = function(buffer) { |
||
5234 | var characters = buffer.takeRemaining(); |
||
5235 | characters = characters.replace(/\u0000/g, function(match, index){ |
||
5236 | tree.parseError('invalid-codepoint'); |
||
5237 | return '\uFFFD'; |
||
5238 | }); |
||
5239 | if (tree.framesetOk && !isAllWhitespaceOrReplacementCharacters(characters)) |
||
5240 | tree.framesetOk = false; |
||
5241 | tree.insertText(characters); |
||
5242 | }; |
||
5243 | |||
5244 | modes.inHeadNoscript = Object.create(modes.base); |
||
5245 | |||
5246 | modes.inHeadNoscript.start_tag_handlers = { |
||
5247 | html: 'startTagHtml', |
||
5248 | basefont: 'startTagBasefontBgsoundLinkMetaNoframesStyle', |
||
5249 | bgsound: 'startTagBasefontBgsoundLinkMetaNoframesStyle', |
||
5250 | link: 'startTagBasefontBgsoundLinkMetaNoframesStyle', |
||
5251 | meta: 'startTagBasefontBgsoundLinkMetaNoframesStyle', |
||
5252 | noframes: 'startTagBasefontBgsoundLinkMetaNoframesStyle', |
||
5253 | style: 'startTagBasefontBgsoundLinkMetaNoframesStyle', |
||
5254 | head: 'startTagHeadNoscript', |
||
5255 | noscript: 'startTagHeadNoscript', |
||
5256 | "-default": 'startTagOther' |
||
5257 | }; |
||
5258 | |||
5259 | modes.inHeadNoscript.end_tag_handlers = { |
||
5260 | noscript: 'endTagNoscript', |
||
5261 | br: 'endTagBr', |
||
5262 | '-default': 'endTagOther' |
||
5263 | }; |
||
5264 | |||
5265 | modes.inHeadNoscript.processCharacters = function(buffer) { |
||
5266 | var leadingWhitespace = buffer.takeLeadingWhitespace(); |
||
5267 | if (leadingWhitespace) |
||
5268 | tree.insertText(leadingWhitespace); |
||
5269 | if (!buffer.length) |
||
5270 | return; |
||
5271 | tree.parseError("unexpected-char-in-frameset"); |
||
5272 | this.anythingElse(); |
||
5273 | tree.insertionMode.processCharacters(buffer); |
||
5274 | }; |
||
5275 | |||
5276 | modes.inHeadNoscript.processComment = function(data) { |
||
5277 | modes.inHead.processComment(data); |
||
5278 | }; |
||
5279 | |||
5280 | modes.inHeadNoscript.startTagBasefontBgsoundLinkMetaNoframesStyle = function(name, attributes) { |
||
5281 | modes.inHead.processStartTag(name, attributes); |
||
5282 | }; |
||
5283 | |||
5284 | modes.inHeadNoscript.startTagHeadNoscript = function(name, attributes) { |
||
5285 | tree.parseError("unexpected-start-tag-in-frameset", {name: name}); |
||
5286 | }; |
||
5287 | |||
5288 | modes.inHeadNoscript.startTagOther = function(name, attributes) { |
||
5289 | tree.parseError("unexpected-start-tag-in-frameset", {name: name}); |
||
5290 | this.anythingElse(); |
||
5291 | tree.insertionMode.processStartTag(name, attributes); |
||
5292 | }; |
||
5293 | |||
5294 | modes.inHeadNoscript.endTagBr = function(name, attributes) { |
||
5295 | tree.parseError("unexpected-end-tag-in-frameset", {name: name}); |
||
5296 | this.anythingElse(); |
||
5297 | tree.insertionMode.processEndTag(name, attributes); |
||
5298 | }; |
||
5299 | |||
5300 | modes.inHeadNoscript.endTagNoscript = function(name, attributes) { |
||
5301 | tree.popElement(); |
||
5302 | tree.setInsertionMode('inHead'); |
||
5303 | }; |
||
5304 | |||
5305 | modes.inHeadNoscript.endTagOther = function(name, attributes) { |
||
5306 | tree.parseError("unexpected-end-tag-in-frameset", {name: name}); |
||
5307 | }; |
||
5308 | |||
5309 | modes.inHeadNoscript.anythingElse = function() { |
||
5310 | tree.popElement(); |
||
5311 | tree.setInsertionMode('inHead'); |
||
5312 | }; |
||
5313 | |||
5314 | |||
5315 | modes.inFrameset = Object.create(modes.base); |
||
5316 | |||
5317 | modes.inFrameset.start_tag_handlers = { |
||
5318 | html: 'startTagHtml', |
||
5319 | frameset: 'startTagFrameset', |
||
5320 | frame: 'startTagFrame', |
||
5321 | noframes: 'startTagNoframes', |
||
5322 | "-default": 'startTagOther' |
||
5323 | }; |
||
5324 | |||
5325 | modes.inFrameset.end_tag_handlers = { |
||
5326 | frameset: 'endTagFrameset', |
||
5327 | noframes: 'endTagNoframes', |
||
5328 | '-default': 'endTagOther' |
||
5329 | }; |
||
5330 | |||
5331 | modes.inFrameset.processCharacters = function(data) { |
||
5332 | tree.parseError("unexpected-char-in-frameset"); |
||
5333 | }; |
||
5334 | |||
5335 | modes.inFrameset.startTagFrameset = function(name, attributes) { |
||
5336 | tree.insertElement(name, attributes); |
||
5337 | }; |
||
5338 | |||
5339 | modes.inFrameset.startTagFrame = function(name, attributes) { |
||
5340 | tree.insertSelfClosingElement(name, attributes); |
||
5341 | }; |
||
5342 | |||
5343 | modes.inFrameset.startTagNoframes = function(name, attributes) { |
||
5344 | modes.inBody.processStartTag(name, attributes); |
||
5345 | }; |
||
5346 | |||
5347 | modes.inFrameset.startTagOther = function(name, attributes) { |
||
5348 | tree.parseError("unexpected-start-tag-in-frameset", {name: name}); |
||
5349 | }; |
||
5350 | |||
5351 | modes.inFrameset.endTagFrameset = function(name, attributes) { |
||
5352 | if (tree.currentStackItem().localName == 'html') { |
||
5353 | tree.parseError("unexpected-frameset-in-frameset-innerhtml"); |
||
5354 | } else { |
||
5355 | tree.popElement(); |
||
5356 | } |
||
5357 | |||
5358 | if (!tree.context && tree.currentStackItem().localName != 'frameset') { |
||
5359 | tree.setInsertionMode('afterFrameset'); |
||
5360 | } |
||
5361 | }; |
||
5362 | |||
5363 | modes.inFrameset.endTagNoframes = function(name) { |
||
5364 | modes.inBody.processEndTag(name); |
||
5365 | }; |
||
5366 | |||
5367 | modes.inFrameset.endTagOther = function(name) { |
||
5368 | tree.parseError("unexpected-end-tag-in-frameset", {name: name}); |
||
5369 | }; |
||
5370 | |||
5371 | modes.inTable = Object.create(modes.base); |
||
5372 | |||
5373 | modes.inTable.start_tag_handlers = { |
||
5374 | html: 'startTagHtml', |
||
5375 | caption: 'startTagCaption', |
||
5376 | colgroup: 'startTagColgroup', |
||
5377 | col: 'startTagCol', |
||
5378 | table: 'startTagTable', |
||
5379 | tbody: 'startTagRowGroup', |
||
5380 | tfoot: 'startTagRowGroup', |
||
5381 | thead: 'startTagRowGroup', |
||
5382 | td: 'startTagImplyTbody', |
||
5383 | th: 'startTagImplyTbody', |
||
5384 | tr: 'startTagImplyTbody', |
||
5385 | style: 'startTagStyleScript', |
||
5386 | script: 'startTagStyleScript', |
||
5387 | input: 'startTagInput', |
||
5388 | form: 'startTagForm', |
||
5389 | '-default': 'startTagOther' |
||
5390 | }; |
||
5391 | |||
5392 | modes.inTable.end_tag_handlers = { |
||
5393 | table: 'endTagTable', |
||
5394 | body: 'endTagIgnore', |
||
5395 | caption: 'endTagIgnore', |
||
5396 | col: 'endTagIgnore', |
||
5397 | colgroup: 'endTagIgnore', |
||
5398 | html: 'endTagIgnore', |
||
5399 | tbody: 'endTagIgnore', |
||
5400 | td: 'endTagIgnore', |
||
5401 | tfoot: 'endTagIgnore', |
||
5402 | th: 'endTagIgnore', |
||
5403 | thead: 'endTagIgnore', |
||
5404 | tr: 'endTagIgnore', |
||
5405 | '-default': 'endTagOther' |
||
5406 | }; |
||
5407 | |||
5408 | modes.inTable.processCharacters = function(data) { |
||
5409 | if (tree.currentStackItem().isFosterParenting()) { |
||
5410 | var originalInsertionMode = tree.insertionModeName; |
||
5411 | tree.setInsertionMode('inTableText'); |
||
5412 | tree.originalInsertionMode = originalInsertionMode; |
||
5413 | tree.insertionMode.processCharacters(data); |
||
5414 | } else { |
||
5415 | tree.redirectAttachToFosterParent = true; |
||
5416 | modes.inBody.processCharacters(data); |
||
5417 | tree.redirectAttachToFosterParent = false; |
||
5418 | } |
||
5419 | }; |
||
5420 | |||
5421 | modes.inTable.startTagCaption = function(name, attributes) { |
||
5422 | tree.openElements.popUntilTableScopeMarker(); |
||
5423 | tree.activeFormattingElements.push(Marker); |
||
5424 | tree.insertElement(name, attributes); |
||
5425 | tree.setInsertionMode('inCaption'); |
||
5426 | }; |
||
5427 | |||
5428 | modes.inTable.startTagColgroup = function(name, attributes) { |
||
5429 | tree.openElements.popUntilTableScopeMarker(); |
||
5430 | tree.insertElement(name, attributes); |
||
5431 | tree.setInsertionMode('inColumnGroup'); |
||
5432 | }; |
||
5433 | |||
5434 | modes.inTable.startTagCol = function(name, attributes) { |
||
5435 | this.startTagColgroup('colgroup', []); |
||
5436 | tree.insertionMode.processStartTag(name, attributes); |
||
5437 | }; |
||
5438 | |||
5439 | modes.inTable.startTagRowGroup = function(name, attributes) { |
||
5440 | tree.openElements.popUntilTableScopeMarker(); |
||
5441 | tree.insertElement(name, attributes); |
||
5442 | tree.setInsertionMode('inTableBody'); |
||
5443 | }; |
||
5444 | |||
5445 | modes.inTable.startTagImplyTbody = function(name, attributes) { |
||
5446 | this.startTagRowGroup('tbody', []); |
||
5447 | tree.insertionMode.processStartTag(name, attributes); |
||
5448 | }; |
||
5449 | |||
5450 | modes.inTable.startTagTable = function(name, attributes) { |
||
5451 | tree.parseError("unexpected-start-tag-implies-end-tag", |
||
5452 | {startName: "table", endName: "table"}); |
||
5453 | tree.insertionMode.processEndTag('table'); |
||
5454 | if (!tree.context) tree.insertionMode.processStartTag(name, attributes); |
||
5455 | }; |
||
5456 | |||
5457 | modes.inTable.startTagStyleScript = function(name, attributes) { |
||
5458 | modes.inHead.processStartTag(name, attributes); |
||
5459 | }; |
||
5460 | |||
5461 | modes.inTable.startTagInput = function(name, attributes) { |
||
5462 | for (var key in attributes) { |
||
5463 | if (attributes[key].nodeName.toLowerCase() == 'type') { |
||
5464 | if (attributes[key].nodeValue.toLowerCase() == 'hidden') { |
||
5465 | tree.parseError("unexpected-hidden-input-in-table"); |
||
5466 | tree.insertElement(name, attributes); |
||
5467 | tree.openElements.pop(); |
||
5468 | return; |
||
5469 | } |
||
5470 | break; |
||
5471 | } |
||
5472 | } |
||
5473 | this.startTagOther(name, attributes); |
||
5474 | }; |
||
5475 | |||
5476 | modes.inTable.startTagForm = function(name, attributes) { |
||
5477 | tree.parseError("unexpected-form-in-table"); |
||
5478 | if (!tree.form) { |
||
5479 | tree.insertElement(name, attributes); |
||
5480 | tree.form = tree.currentStackItem(); |
||
5481 | tree.openElements.pop(); |
||
5482 | } |
||
5483 | }; |
||
5484 | |||
5485 | modes.inTable.startTagOther = function(name, attributes, selfClosing) { |
||
5486 | tree.parseError("unexpected-start-tag-implies-table-voodoo", {name: name}); |
||
5487 | tree.redirectAttachToFosterParent = true; |
||
5488 | modes.inBody.processStartTag(name, attributes, selfClosing); |
||
5489 | tree.redirectAttachToFosterParent = false; |
||
5490 | }; |
||
5491 | |||
5492 | modes.inTable.endTagTable = function(name) { |
||
5493 | if (tree.openElements.inTableScope(name)) { |
||
5494 | tree.generateImpliedEndTags(); |
||
5495 | if (tree.currentStackItem().localName != name) { |
||
5496 | tree.parseError("end-tag-too-early-named", {gotName: 'table', expectedName: tree.currentStackItem().localName}); |
||
5497 | } |
||
5498 | |||
5499 | tree.openElements.popUntilPopped('table'); |
||
5500 | tree.resetInsertionMode(); |
||
5501 | } else { |
||
5502 | assert.ok(tree.context); |
||
5503 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5504 | } |
||
5505 | }; |
||
5506 | |||
5507 | modes.inTable.endTagIgnore = function(name) { |
||
5508 | tree.parseError("unexpected-end-tag", {name: name}); |
||
5509 | }; |
||
5510 | |||
5511 | modes.inTable.endTagOther = function(name) { |
||
5512 | tree.parseError("unexpected-end-tag-implies-table-voodoo", {name: name}); |
||
5513 | tree.redirectAttachToFosterParent = true; |
||
5514 | modes.inBody.processEndTag(name); |
||
5515 | tree.redirectAttachToFosterParent = false; |
||
5516 | }; |
||
5517 | |||
5518 | modes.inTableText = Object.create(modes.base); |
||
5519 | |||
5520 | modes.inTableText.flushCharacters = function() { |
||
5521 | var characters = tree.pendingTableCharacters.join(''); |
||
5522 | if (!isAllWhitespace(characters)) { |
||
5523 | tree.redirectAttachToFosterParent = true; |
||
5524 | tree.reconstructActiveFormattingElements(); |
||
5525 | tree.insertText(characters); |
||
5526 | tree.framesetOk = false; |
||
5527 | tree.redirectAttachToFosterParent = false; |
||
5528 | } else { |
||
5529 | tree.insertText(characters); |
||
5530 | } |
||
5531 | tree.pendingTableCharacters = []; |
||
5532 | }; |
||
5533 | |||
5534 | modes.inTableText.processComment = function(data) { |
||
5535 | this.flushCharacters(); |
||
5536 | tree.setInsertionMode(tree.originalInsertionMode); |
||
5537 | tree.insertionMode.processComment(data); |
||
5538 | }; |
||
5539 | |||
5540 | modes.inTableText.processEOF = function(data) { |
||
5541 | this.flushCharacters(); |
||
5542 | tree.setInsertionMode(tree.originalInsertionMode); |
||
5543 | tree.insertionMode.processEOF(); |
||
5544 | }; |
||
5545 | |||
5546 | modes.inTableText.processCharacters = function(buffer) { |
||
5547 | var characters = buffer.takeRemaining(); |
||
5548 | characters = characters.replace(/\u0000/g, function(match, index){ |
||
5549 | tree.parseError("invalid-codepoint"); |
||
5550 | return ''; |
||
5551 | }); |
||
5552 | if (!characters) |
||
5553 | return; |
||
5554 | tree.pendingTableCharacters.push(characters); |
||
5555 | }; |
||
5556 | |||
5557 | modes.inTableText.processStartTag = function(name, attributes, selfClosing) { |
||
5558 | this.flushCharacters(); |
||
5559 | tree.setInsertionMode(tree.originalInsertionMode); |
||
5560 | tree.insertionMode.processStartTag(name, attributes, selfClosing); |
||
5561 | }; |
||
5562 | |||
5563 | modes.inTableText.processEndTag = function(name, attributes) { |
||
5564 | this.flushCharacters(); |
||
5565 | tree.setInsertionMode(tree.originalInsertionMode); |
||
5566 | tree.insertionMode.processEndTag(name, attributes); |
||
5567 | }; |
||
5568 | |||
5569 | modes.inTableBody = Object.create(modes.base); |
||
5570 | |||
5571 | modes.inTableBody.start_tag_handlers = { |
||
5572 | html: 'startTagHtml', |
||
5573 | tr: 'startTagTr', |
||
5574 | td: 'startTagTableCell', |
||
5575 | th: 'startTagTableCell', |
||
5576 | caption: 'startTagTableOther', |
||
5577 | col: 'startTagTableOther', |
||
5578 | colgroup: 'startTagTableOther', |
||
5579 | tbody: 'startTagTableOther', |
||
5580 | tfoot: 'startTagTableOther', |
||
5581 | thead: 'startTagTableOther', |
||
5582 | '-default': 'startTagOther' |
||
5583 | }; |
||
5584 | |||
5585 | modes.inTableBody.end_tag_handlers = { |
||
5586 | table: 'endTagTable', |
||
5587 | tbody: 'endTagTableRowGroup', |
||
5588 | tfoot: 'endTagTableRowGroup', |
||
5589 | thead: 'endTagTableRowGroup', |
||
5590 | body: 'endTagIgnore', |
||
5591 | caption: 'endTagIgnore', |
||
5592 | col: 'endTagIgnore', |
||
5593 | colgroup: 'endTagIgnore', |
||
5594 | html: 'endTagIgnore', |
||
5595 | td: 'endTagIgnore', |
||
5596 | th: 'endTagIgnore', |
||
5597 | tr: 'endTagIgnore', |
||
5598 | '-default': 'endTagOther' |
||
5599 | }; |
||
5600 | |||
5601 | modes.inTableBody.processCharacters = function(data) { |
||
5602 | modes.inTable.processCharacters(data); |
||
5603 | }; |
||
5604 | |||
5605 | modes.inTableBody.startTagTr = function(name, attributes) { |
||
5606 | tree.openElements.popUntilTableBodyScopeMarker(); |
||
5607 | tree.insertElement(name, attributes); |
||
5608 | tree.setInsertionMode('inRow'); |
||
5609 | }; |
||
5610 | |||
5611 | modes.inTableBody.startTagTableCell = function(name, attributes) { |
||
5612 | tree.parseError("unexpected-cell-in-table-body", {name: name}); |
||
5613 | this.startTagTr('tr', []); |
||
5614 | tree.insertionMode.processStartTag(name, attributes); |
||
5615 | }; |
||
5616 | |||
5617 | modes.inTableBody.startTagTableOther = function(name, attributes) { |
||
5618 | if (tree.openElements.inTableScope('tbody') || tree.openElements.inTableScope('thead') || tree.openElements.inTableScope('tfoot')) { |
||
5619 | tree.openElements.popUntilTableBodyScopeMarker(); |
||
5620 | this.endTagTableRowGroup(tree.currentStackItem().localName); |
||
5621 | tree.insertionMode.processStartTag(name, attributes); |
||
5622 | } else { |
||
5623 | tree.parseError('unexpected-start-tag', {name: name}); |
||
5624 | } |
||
5625 | }; |
||
5626 | |||
5627 | modes.inTableBody.startTagOther = function(name, attributes) { |
||
5628 | modes.inTable.processStartTag(name, attributes); |
||
5629 | }; |
||
5630 | |||
5631 | modes.inTableBody.endTagTableRowGroup = function(name) { |
||
5632 | if (tree.openElements.inTableScope(name)) { |
||
5633 | tree.openElements.popUntilTableBodyScopeMarker(); |
||
5634 | tree.popElement(); |
||
5635 | tree.setInsertionMode('inTable'); |
||
5636 | } else { |
||
5637 | tree.parseError('unexpected-end-tag-in-table-body', {name: name}); |
||
5638 | } |
||
5639 | }; |
||
5640 | |||
5641 | modes.inTableBody.endTagTable = function(name) { |
||
5642 | if (tree.openElements.inTableScope('tbody') || tree.openElements.inTableScope('thead') || tree.openElements.inTableScope('tfoot')) { |
||
5643 | tree.openElements.popUntilTableBodyScopeMarker(); |
||
5644 | this.endTagTableRowGroup(tree.currentStackItem().localName); |
||
5645 | tree.insertionMode.processEndTag(name); |
||
5646 | } else { |
||
5647 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5648 | } |
||
5649 | }; |
||
5650 | |||
5651 | modes.inTableBody.endTagIgnore = function(name) { |
||
5652 | tree.parseError("unexpected-end-tag-in-table-body", {name: name}); |
||
5653 | }; |
||
5654 | |||
5655 | modes.inTableBody.endTagOther = function(name) { |
||
5656 | modes.inTable.processEndTag(name); |
||
5657 | }; |
||
5658 | |||
5659 | modes.inSelect = Object.create(modes.base); |
||
5660 | |||
5661 | modes.inSelect.start_tag_handlers = { |
||
5662 | html: 'startTagHtml', |
||
5663 | option: 'startTagOption', |
||
5664 | optgroup: 'startTagOptgroup', |
||
5665 | select: 'startTagSelect', |
||
5666 | input: 'startTagInput', |
||
5667 | keygen: 'startTagInput', |
||
5668 | textarea: 'startTagInput', |
||
5669 | script: 'startTagScript', |
||
5670 | '-default': 'startTagOther' |
||
5671 | }; |
||
5672 | |||
5673 | modes.inSelect.end_tag_handlers = { |
||
5674 | option: 'endTagOption', |
||
5675 | optgroup: 'endTagOptgroup', |
||
5676 | select: 'endTagSelect', |
||
5677 | caption: 'endTagTableElements', |
||
5678 | table: 'endTagTableElements', |
||
5679 | tbody: 'endTagTableElements', |
||
5680 | tfoot: 'endTagTableElements', |
||
5681 | thead: 'endTagTableElements', |
||
5682 | tr: 'endTagTableElements', |
||
5683 | td: 'endTagTableElements', |
||
5684 | th: 'endTagTableElements', |
||
5685 | '-default': 'endTagOther' |
||
5686 | }; |
||
5687 | |||
5688 | modes.inSelect.processCharacters = function(buffer) { |
||
5689 | var data = buffer.takeRemaining(); |
||
5690 | data = data.replace(/\u0000/g, function(match, index){ |
||
5691 | tree.parseError("invalid-codepoint"); |
||
5692 | return ''; |
||
5693 | }); |
||
5694 | if (!data) |
||
5695 | return; |
||
5696 | tree.insertText(data); |
||
5697 | }; |
||
5698 | |||
5699 | modes.inSelect.startTagOption = function(name, attributes) { |
||
5700 | if (tree.currentStackItem().localName == 'option') |
||
5701 | tree.popElement(); |
||
5702 | tree.insertElement(name, attributes); |
||
5703 | }; |
||
5704 | |||
5705 | modes.inSelect.startTagOptgroup = function(name, attributes) { |
||
5706 | if (tree.currentStackItem().localName == 'option') |
||
5707 | tree.popElement(); |
||
5708 | if (tree.currentStackItem().localName == 'optgroup') |
||
5709 | tree.popElement(); |
||
5710 | tree.insertElement(name, attributes); |
||
5711 | }; |
||
5712 | |||
5713 | modes.inSelect.endTagOption = function(name) { |
||
5714 | if (tree.currentStackItem().localName !== 'option') { |
||
5715 | tree.parseError('unexpected-end-tag-in-select', {name: name}); |
||
5716 | return; |
||
5717 | } |
||
5718 | tree.popElement(); |
||
5719 | }; |
||
5720 | |||
5721 | modes.inSelect.endTagOptgroup = function(name) { |
||
5722 | if (tree.currentStackItem().localName == 'option' && tree.openElements.item(tree.openElements.length - 2).localName == 'optgroup') { |
||
5723 | tree.popElement(); |
||
5724 | } |
||
5725 | if (tree.currentStackItem().localName == 'optgroup') { |
||
5726 | tree.popElement(); |
||
5727 | } else { |
||
5728 | tree.parseError('unexpected-end-tag-in-select', {name: 'optgroup'}); |
||
5729 | } |
||
5730 | }; |
||
5731 | |||
5732 | modes.inSelect.startTagSelect = function(name) { |
||
5733 | tree.parseError("unexpected-select-in-select"); |
||
5734 | this.endTagSelect('select'); |
||
5735 | }; |
||
5736 | |||
5737 | modes.inSelect.endTagSelect = function(name) { |
||
5738 | if (tree.openElements.inTableScope('select')) { |
||
5739 | tree.openElements.popUntilPopped('select'); |
||
5740 | tree.resetInsertionMode(); |
||
5741 | } else { |
||
5742 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5743 | } |
||
5744 | }; |
||
5745 | |||
5746 | modes.inSelect.startTagInput = function(name, attributes) { |
||
5747 | tree.parseError("unexpected-input-in-select"); |
||
5748 | if (tree.openElements.inSelectScope('select')) { |
||
5749 | this.endTagSelect('select'); |
||
5750 | tree.insertionMode.processStartTag(name, attributes); |
||
5751 | } |
||
5752 | }; |
||
5753 | |||
5754 | modes.inSelect.startTagScript = function(name, attributes) { |
||
5755 | modes.inHead.processStartTag(name, attributes); |
||
5756 | }; |
||
5757 | |||
5758 | modes.inSelect.endTagTableElements = function(name) { |
||
5759 | tree.parseError('unexpected-end-tag-in-select', {name: name}); |
||
5760 | if (tree.openElements.inTableScope(name)) { |
||
5761 | this.endTagSelect('select'); |
||
5762 | tree.insertionMode.processEndTag(name); |
||
5763 | } |
||
5764 | }; |
||
5765 | |||
5766 | modes.inSelect.startTagOther = function(name, attributes) { |
||
5767 | tree.parseError("unexpected-start-tag-in-select", {name: name}); |
||
5768 | }; |
||
5769 | |||
5770 | modes.inSelect.endTagOther = function(name) { |
||
5771 | tree.parseError('unexpected-end-tag-in-select', {name: name}); |
||
5772 | }; |
||
5773 | |||
5774 | modes.inSelectInTable = Object.create(modes.base); |
||
5775 | |||
5776 | modes.inSelectInTable.start_tag_handlers = { |
||
5777 | caption: 'startTagTable', |
||
5778 | table: 'startTagTable', |
||
5779 | tbody: 'startTagTable', |
||
5780 | tfoot: 'startTagTable', |
||
5781 | thead: 'startTagTable', |
||
5782 | tr: 'startTagTable', |
||
5783 | td: 'startTagTable', |
||
5784 | th: 'startTagTable', |
||
5785 | '-default': 'startTagOther' |
||
5786 | }; |
||
5787 | |||
5788 | modes.inSelectInTable.end_tag_handlers = { |
||
5789 | caption: 'endTagTable', |
||
5790 | table: 'endTagTable', |
||
5791 | tbody: 'endTagTable', |
||
5792 | tfoot: 'endTagTable', |
||
5793 | thead: 'endTagTable', |
||
5794 | tr: 'endTagTable', |
||
5795 | td: 'endTagTable', |
||
5796 | th: 'endTagTable', |
||
5797 | '-default': 'endTagOther' |
||
5798 | }; |
||
5799 | |||
5800 | modes.inSelectInTable.processCharacters = function(data) { |
||
5801 | modes.inSelect.processCharacters(data); |
||
5802 | }; |
||
5803 | |||
5804 | modes.inSelectInTable.startTagTable = function(name, attributes) { |
||
5805 | tree.parseError("unexpected-table-element-start-tag-in-select-in-table", {name: name}); |
||
5806 | this.endTagOther("select"); |
||
5807 | tree.insertionMode.processStartTag(name, attributes); |
||
5808 | }; |
||
5809 | |||
5810 | modes.inSelectInTable.startTagOther = function(name, attributes, selfClosing) { |
||
5811 | modes.inSelect.processStartTag(name, attributes, selfClosing); |
||
5812 | }; |
||
5813 | |||
5814 | modes.inSelectInTable.endTagTable = function(name) { |
||
5815 | tree.parseError("unexpected-table-element-end-tag-in-select-in-table", {name: name}); |
||
5816 | if (tree.openElements.inTableScope(name)) { |
||
5817 | this.endTagOther("select"); |
||
5818 | tree.insertionMode.processEndTag(name); |
||
5819 | } |
||
5820 | }; |
||
5821 | |||
5822 | modes.inSelectInTable.endTagOther = function(name) { |
||
5823 | modes.inSelect.processEndTag(name); |
||
5824 | }; |
||
5825 | |||
5826 | modes.inRow = Object.create(modes.base); |
||
5827 | |||
5828 | modes.inRow.start_tag_handlers = { |
||
5829 | html: 'startTagHtml', |
||
5830 | td: 'startTagTableCell', |
||
5831 | th: 'startTagTableCell', |
||
5832 | caption: 'startTagTableOther', |
||
5833 | col: 'startTagTableOther', |
||
5834 | colgroup: 'startTagTableOther', |
||
5835 | tbody: 'startTagTableOther', |
||
5836 | tfoot: 'startTagTableOther', |
||
5837 | thead: 'startTagTableOther', |
||
5838 | tr: 'startTagTableOther', |
||
5839 | '-default': 'startTagOther' |
||
5840 | }; |
||
5841 | |||
5842 | modes.inRow.end_tag_handlers = { |
||
5843 | tr: 'endTagTr', |
||
5844 | table: 'endTagTable', |
||
5845 | tbody: 'endTagTableRowGroup', |
||
5846 | tfoot: 'endTagTableRowGroup', |
||
5847 | thead: 'endTagTableRowGroup', |
||
5848 | body: 'endTagIgnore', |
||
5849 | caption: 'endTagIgnore', |
||
5850 | col: 'endTagIgnore', |
||
5851 | colgroup: 'endTagIgnore', |
||
5852 | html: 'endTagIgnore', |
||
5853 | td: 'endTagIgnore', |
||
5854 | th: 'endTagIgnore', |
||
5855 | '-default': 'endTagOther' |
||
5856 | }; |
||
5857 | |||
5858 | modes.inRow.processCharacters = function(data) { |
||
5859 | modes.inTable.processCharacters(data); |
||
5860 | }; |
||
5861 | |||
5862 | modes.inRow.startTagTableCell = function(name, attributes) { |
||
5863 | tree.openElements.popUntilTableRowScopeMarker(); |
||
5864 | tree.insertElement(name, attributes); |
||
5865 | tree.setInsertionMode('inCell'); |
||
5866 | tree.activeFormattingElements.push(Marker); |
||
5867 | }; |
||
5868 | |||
5869 | modes.inRow.startTagTableOther = function(name, attributes) { |
||
5870 | var ignoreEndTag = this.ignoreEndTagTr(); |
||
5871 | this.endTagTr('tr'); |
||
5872 | if (!ignoreEndTag) tree.insertionMode.processStartTag(name, attributes); |
||
5873 | }; |
||
5874 | |||
5875 | modes.inRow.startTagOther = function(name, attributes, selfClosing) { |
||
5876 | modes.inTable.processStartTag(name, attributes, selfClosing); |
||
5877 | }; |
||
5878 | |||
5879 | modes.inRow.endTagTr = function(name) { |
||
5880 | if (this.ignoreEndTagTr()) { |
||
5881 | assert.ok(tree.context); |
||
5882 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5883 | } else { |
||
5884 | tree.openElements.popUntilTableRowScopeMarker(); |
||
5885 | tree.popElement(); |
||
5886 | tree.setInsertionMode('inTableBody'); |
||
5887 | } |
||
5888 | }; |
||
5889 | |||
5890 | modes.inRow.endTagTable = function(name) { |
||
5891 | var ignoreEndTag = this.ignoreEndTagTr(); |
||
5892 | this.endTagTr('tr'); |
||
5893 | if (!ignoreEndTag) tree.insertionMode.processEndTag(name); |
||
5894 | }; |
||
5895 | |||
5896 | modes.inRow.endTagTableRowGroup = function(name) { |
||
5897 | if (tree.openElements.inTableScope(name)) { |
||
5898 | this.endTagTr('tr'); |
||
5899 | tree.insertionMode.processEndTag(name); |
||
5900 | } else { |
||
5901 | tree.parseError('unexpected-end-tag', {name: name}); |
||
5902 | } |
||
5903 | }; |
||
5904 | |||
5905 | modes.inRow.endTagIgnore = function(name) { |
||
5906 | tree.parseError("unexpected-end-tag-in-table-row", {name: name}); |
||
5907 | }; |
||
5908 | |||
5909 | modes.inRow.endTagOther = function(name) { |
||
5910 | modes.inTable.processEndTag(name); |
||
5911 | }; |
||
5912 | |||
5913 | modes.inRow.ignoreEndTagTr = function() { |
||
5914 | return !tree.openElements.inTableScope('tr'); |
||
5915 | }; |
||
5916 | |||
5917 | modes.afterAfterFrameset = Object.create(modes.base); |
||
5918 | |||
5919 | modes.afterAfterFrameset.start_tag_handlers = { |
||
5920 | html: 'startTagHtml', |
||
5921 | noframes: 'startTagNoFrames', |
||
5922 | '-default': 'startTagOther' |
||
5923 | }; |
||
5924 | |||
5925 | modes.afterAfterFrameset.processEOF = function() {}; |
||
5926 | |||
5927 | modes.afterAfterFrameset.processComment = function(data) { |
||
5928 | tree.insertComment(data, tree.document); |
||
5929 | }; |
||
5930 | |||
5931 | modes.afterAfterFrameset.processCharacters = function(buffer) { |
||
5932 | var characters = buffer.takeRemaining(); |
||
5933 | var whitespace = ""; |
||
5934 | for (var i = 0; i < characters.length; i++) { |
||
5935 | var ch = characters[i]; |
||
5936 | if (isWhitespace(ch)) |
||
5937 | whitespace += ch; |
||
5938 | } |
||
5939 | if (whitespace) { |
||
5940 | tree.reconstructActiveFormattingElements(); |
||
5941 | tree.insertText(whitespace); |
||
5942 | } |
||
5943 | if (whitespace.length < characters.length) |
||
5944 | tree.parseError('expected-eof-but-got-char'); |
||
5945 | }; |
||
5946 | |||
5947 | modes.afterAfterFrameset.startTagNoFrames = function(name, attributes) { |
||
5948 | modes.inHead.processStartTag(name, attributes); |
||
5949 | }; |
||
5950 | |||
5951 | modes.afterAfterFrameset.startTagOther = function(name, attributes, selfClosing) { |
||
5952 | tree.parseError('expected-eof-but-got-start-tag', {name: name}); |
||
5953 | }; |
||
5954 | |||
5955 | modes.afterAfterFrameset.processEndTag = function(name, attributes) { |
||
5956 | tree.parseError('expected-eof-but-got-end-tag', {name: name}); |
||
5957 | }; |
||
5958 | |||
5959 | modes.text = Object.create(modes.base); |
||
5960 | |||
5961 | modes.text.start_tag_handlers = { |
||
5962 | '-default': 'startTagOther' |
||
5963 | }; |
||
5964 | |||
5965 | modes.text.end_tag_handlers = { |
||
5966 | script: 'endTagScript', |
||
5967 | '-default': 'endTagOther' |
||
5968 | }; |
||
5969 | |||
5970 | modes.text.processCharacters = function(buffer) { |
||
5971 | if (tree.shouldSkipLeadingNewline) { |
||
5972 | tree.shouldSkipLeadingNewline = false; |
||
5973 | buffer.skipAtMostOneLeadingNewline(); |
||
5974 | } |
||
5975 | var data = buffer.takeRemaining(); |
||
5976 | if (!data) |
||
5977 | return; |
||
5978 | tree.insertText(data); |
||
5979 | }; |
||
5980 | |||
5981 | modes.text.processEOF = function() { |
||
5982 | tree.parseError("expected-named-closing-tag-but-got-eof", |
||
5983 | {name: tree.currentStackItem().localName}); |
||
5984 | tree.openElements.pop(); |
||
5985 | tree.setInsertionMode(tree.originalInsertionMode); |
||
5986 | tree.insertionMode.processEOF(); |
||
5987 | }; |
||
5988 | |||
5989 | modes.text.startTagOther = function(name) { |
||
5990 | throw "Tried to process start tag " + name + " in RCDATA/RAWTEXT mode"; |
||
5991 | }; |
||
5992 | |||
5993 | modes.text.endTagScript = function(name) { |
||
5994 | var node = tree.openElements.pop(); |
||
5995 | assert.ok(node.localName == 'script'); |
||
5996 | tree.setInsertionMode(tree.originalInsertionMode); |
||
5997 | }; |
||
5998 | |||
5999 | modes.text.endTagOther = function(name) { |
||
6000 | tree.openElements.pop(); |
||
6001 | tree.setInsertionMode(tree.originalInsertionMode); |
||
6002 | }; |
||
6003 | } |
||
6004 | |||
6005 | TreeBuilder.prototype.setInsertionMode = function(name) { |
||
6006 | this.insertionMode = this.insertionModes[name]; |
||
6007 | this.insertionModeName = name; |
||
6008 | }; |
||
6009 | TreeBuilder.prototype.adoptionAgencyEndTag = function(name) { |
||
6010 | var outerIterationLimit = 8; |
||
6011 | var innerIterationLimit = 3; |
||
6012 | var formattingElement; |
||
6013 | |||
6014 | function isActiveFormattingElement(el) { |
||
6015 | return el === formattingElement; |
||
6016 | } |
||
6017 | |||
6018 | var outerLoopCounter = 0; |
||
6019 | |||
6020 | while (outerLoopCounter++ < outerIterationLimit) { |
||
6021 | formattingElement = this.elementInActiveFormattingElements(name); |
||
6022 | |||
6023 | if (!formattingElement || (this.openElements.contains(formattingElement) && !this.openElements.inScope(formattingElement.localName))) { |
||
6024 | this.parseError('adoption-agency-1.1', {name: name}); |
||
6025 | return false; |
||
6026 | } |
||
6027 | if (!this.openElements.contains(formattingElement)) { |
||
6028 | this.parseError('adoption-agency-1.2', {name: name}); |
||
6029 | this.removeElementFromActiveFormattingElements(formattingElement); |
||
6030 | return true; |
||
6031 | } |
||
6032 | if (!this.openElements.inScope(formattingElement.localName)) { |
||
6033 | this.parseError('adoption-agency-4.4', {name: name}); |
||
6034 | } |
||
6035 | |||
6036 | if (formattingElement != this.currentStackItem()) { |
||
6037 | this.parseError('adoption-agency-1.3', {name: name}); |
||
6038 | } |
||
6039 | var furthestBlock = this.openElements.furthestBlockForFormattingElement(formattingElement.node); |
||
6040 | |||
6041 | if (!furthestBlock) { |
||
6042 | this.openElements.remove_openElements_until(isActiveFormattingElement); |
||
6043 | this.removeElementFromActiveFormattingElements(formattingElement); |
||
6044 | return true; |
||
6045 | } |
||
6046 | |||
6047 | var afeIndex = this.openElements.elements.indexOf(formattingElement); |
||
6048 | var commonAncestor = this.openElements.item(afeIndex - 1); |
||
6049 | |||
6050 | var bookmark = this.activeFormattingElements.indexOf(formattingElement); |
||
6051 | |||
6052 | var node = furthestBlock; |
||
6053 | var lastNode = furthestBlock; |
||
6054 | var index = this.openElements.elements.indexOf(node); |
||
6055 | |||
6056 | var innerLoopCounter = 0; |
||
6057 | while (innerLoopCounter++ < innerIterationLimit) { |
||
6058 | index -= 1; |
||
6059 | node = this.openElements.item(index); |
||
6060 | if (this.activeFormattingElements.indexOf(node) < 0) { |
||
6061 | this.openElements.elements.splice(index, 1); |
||
6062 | continue; |
||
6063 | } |
||
6064 | if (node == formattingElement) |
||
6065 | break; |
||
6066 | |||
6067 | if (lastNode == furthestBlock) |
||
6068 | bookmark = this.activeFormattingElements.indexOf(node) + 1; |
||
6069 | |||
6070 | var clone = this.createElement(node.namespaceURI, node.localName, node.attributes); |
||
6071 | var newNode = new StackItem(node.namespaceURI, node.localName, node.attributes, clone); |
||
6072 | |||
6073 | this.activeFormattingElements[this.activeFormattingElements.indexOf(node)] = newNode; |
||
6074 | this.openElements.elements[this.openElements.elements.indexOf(node)] = newNode; |
||
6075 | |||
6076 | node = newNode; |
||
6077 | this.detachFromParent(lastNode.node); |
||
6078 | this.attachNode(lastNode.node, node.node); |
||
6079 | lastNode = node; |
||
6080 | } |
||
6081 | |||
6082 | this.detachFromParent(lastNode.node); |
||
6083 | if (commonAncestor.isFosterParenting()) { |
||
6084 | this.insertIntoFosterParent(lastNode.node); |
||
6085 | } else { |
||
6086 | this.attachNode(lastNode.node, commonAncestor.node); |
||
6087 | } |
||
6088 | |||
6089 | var clone = this.createElement("http://www.w3.org/1999/xhtml", formattingElement.localName, formattingElement.attributes); |
||
6090 | var formattingClone = new StackItem(formattingElement.namespaceURI, formattingElement.localName, formattingElement.attributes, clone); |
||
6091 | |||
6092 | this.reparentChildren(furthestBlock.node, clone); |
||
6093 | this.attachNode(clone, furthestBlock.node); |
||
6094 | |||
6095 | this.removeElementFromActiveFormattingElements(formattingElement); |
||
6096 | this.activeFormattingElements.splice(Math.min(bookmark, this.activeFormattingElements.length), 0, formattingClone); |
||
6097 | |||
6098 | this.openElements.remove(formattingElement); |
||
6099 | this.openElements.elements.splice(this.openElements.elements.indexOf(furthestBlock) + 1, 0, formattingClone); |
||
6100 | } |
||
6101 | |||
6102 | return true; |
||
6103 | }; |
||
6104 | |||
6105 | TreeBuilder.prototype.start = function() { |
||
6106 | throw "Not mplemented"; |
||
6107 | }; |
||
6108 | |||
6109 | TreeBuilder.prototype.startTokenization = function(tokenizer) { |
||
6110 | this.tokenizer = tokenizer; |
||
6111 | this.compatMode = "no quirks"; |
||
6112 | this.originalInsertionMode = "initial"; |
||
6113 | this.framesetOk = true; |
||
6114 | this.openElements = new ElementStack(); |
||
6115 | this.activeFormattingElements = []; |
||
6116 | this.start(); |
||
6117 | if (this.context) { |
||
6118 | switch(this.context) { |
||
6119 | case 'title': |
||
6120 | case 'textarea': |
||
6121 | this.tokenizer.setState(Tokenizer.RCDATA); |
||
6122 | break; |
||
6123 | case 'style': |
||
6124 | case 'xmp': |
||
6125 | case 'iframe': |
||
6126 | case 'noembed': |
||
6127 | case 'noframes': |
||
6128 | this.tokenizer.setState(Tokenizer.RAWTEXT); |
||
6129 | break; |
||
6130 | case 'script': |
||
6131 | this.tokenizer.setState(Tokenizer.SCRIPT_DATA); |
||
6132 | break; |
||
6133 | case 'noscript': |
||
6134 | if (this.scriptingEnabled) |
||
6135 | this.tokenizer.setState(Tokenizer.RAWTEXT); |
||
6136 | break; |
||
6137 | case 'plaintext': |
||
6138 | this.tokenizer.setState(Tokenizer.PLAINTEXT); |
||
6139 | break; |
||
6140 | } |
||
6141 | this.insertHtmlElement(); |
||
6142 | this.resetInsertionMode(); |
||
6143 | } else { |
||
6144 | this.setInsertionMode('initial'); |
||
6145 | } |
||
6146 | }; |
||
6147 | |||
6148 | TreeBuilder.prototype.processToken = function(token) { |
||
6149 | this.selfClosingFlagAcknowledged = false; |
||
6150 | |||
6151 | var currentNode = this.openElements.top || null; |
||
6152 | var insertionMode; |
||
6153 | if (!currentNode || !currentNode.isForeign() || |
||
6154 | (currentNode.isMathMLTextIntegrationPoint() && |
||
6155 | ((token.type == 'StartTag' && |
||
6156 | !(token.name in {mglyph:0, malignmark:0})) || |
||
6157 | (token.type === 'Characters')) |
||
6158 | ) || |
||
6159 | (currentNode.namespaceURI == "http://www.w3.org/1998/Math/MathML" && |
||
6160 | currentNode.localName == 'annotation-xml' && |
||
6161 | token.type == 'StartTag' && token.name == 'svg' |
||
6162 | ) || |
||
6163 | (currentNode.isHtmlIntegrationPoint() && |
||
6164 | token.type in {StartTag:0, Characters:0} |
||
6165 | ) || |
||
6166 | token.type == 'EOF' |
||
6167 | ) { |
||
6168 | insertionMode = this.insertionMode; |
||
6169 | } else { |
||
6170 | insertionMode = this.insertionModes.inForeignContent; |
||
6171 | } |
||
6172 | switch(token.type) { |
||
6173 | case 'Characters': |
||
6174 | var buffer = new CharacterBuffer(token.data); |
||
6175 | insertionMode.processCharacters(buffer); |
||
6176 | break; |
||
6177 | case 'Comment': |
||
6178 | insertionMode.processComment(token.data); |
||
6179 | break; |
||
6180 | case 'StartTag': |
||
6181 | insertionMode.processStartTag(token.name, token.data, token.selfClosing); |
||
6182 | break; |
||
6183 | case 'EndTag': |
||
6184 | insertionMode.processEndTag(token.name); |
||
6185 | break; |
||
6186 | case 'Doctype': |
||
6187 | insertionMode.processDoctype(token.name, token.publicId, token.systemId, token.forceQuirks); |
||
6188 | break; |
||
6189 | case 'EOF': |
||
6190 | insertionMode.processEOF(); |
||
6191 | break; |
||
6192 | } |
||
6193 | }; |
||
6194 | TreeBuilder.prototype.isCdataSectionAllowed = function() { |
||
6195 | return this.openElements.length > 0 && this.currentStackItem().isForeign(); |
||
6196 | }; |
||
6197 | TreeBuilder.prototype.isSelfClosingFlagAcknowledged = function() { |
||
6198 | return this.selfClosingFlagAcknowledged; |
||
6199 | }; |
||
6200 | |||
6201 | TreeBuilder.prototype.createElement = function(namespaceURI, localName, attributes) { |
||
6202 | throw new Error("Not implemented"); |
||
6203 | }; |
||
6204 | |||
6205 | TreeBuilder.prototype.attachNode = function(child, parent) { |
||
6206 | throw new Error("Not implemented"); |
||
6207 | }; |
||
6208 | |||
6209 | TreeBuilder.prototype.attachNodeToFosterParent = function(child, table, stackParent) { |
||
6210 | throw new Error("Not implemented"); |
||
6211 | }; |
||
6212 | |||
6213 | TreeBuilder.prototype.detachFromParent = function(node) { |
||
6214 | throw new Error("Not implemented"); |
||
6215 | }; |
||
6216 | |||
6217 | TreeBuilder.prototype.addAttributesToElement = function(element, attributes) { |
||
6218 | throw new Error("Not implemented"); |
||
6219 | }; |
||
6220 | |||
6221 | TreeBuilder.prototype.insertHtmlElement = function(attributes) { |
||
6222 | var root = this.createElement("http://www.w3.org/1999/xhtml", 'html', attributes); |
||
6223 | this.attachNode(root, this.document); |
||
6224 | this.openElements.pushHtmlElement(new StackItem("http://www.w3.org/1999/xhtml", 'html', attributes, root)); |
||
6225 | return root; |
||
6226 | }; |
||
6227 | |||
6228 | TreeBuilder.prototype.insertHeadElement = function(attributes) { |
||
6229 | var element = this.createElement("http://www.w3.org/1999/xhtml", "head", attributes); |
||
6230 | this.head = new StackItem("http://www.w3.org/1999/xhtml", "head", attributes, element); |
||
6231 | this.attachNode(element, this.openElements.top.node); |
||
6232 | this.openElements.pushHeadElement(this.head); |
||
6233 | return element; |
||
6234 | }; |
||
6235 | |||
6236 | TreeBuilder.prototype.insertBodyElement = function(attributes) { |
||
6237 | var element = this.createElement("http://www.w3.org/1999/xhtml", "body", attributes); |
||
6238 | this.attachNode(element, this.openElements.top.node); |
||
6239 | this.openElements.pushBodyElement(new StackItem("http://www.w3.org/1999/xhtml", "body", attributes, element)); |
||
6240 | return element; |
||
6241 | }; |
||
6242 | |||
6243 | TreeBuilder.prototype.insertIntoFosterParent = function(node) { |
||
6244 | var tableIndex = this.openElements.findIndex('table'); |
||
6245 | var tableElement = this.openElements.item(tableIndex).node; |
||
6246 | if (tableIndex === 0) |
||
6247 | return this.attachNode(node, tableElement); |
||
6248 | this.attachNodeToFosterParent(node, tableElement, this.openElements.item(tableIndex - 1).node); |
||
6249 | }; |
||
6250 | |||
6251 | TreeBuilder.prototype.insertElement = function(name, attributes, namespaceURI, selfClosing) { |
||
6252 | if (!namespaceURI) |
||
6253 | namespaceURI = "http://www.w3.org/1999/xhtml"; |
||
6254 | var element = this.createElement(namespaceURI, name, attributes); |
||
6255 | if (this.shouldFosterParent()) |
||
6256 | this.insertIntoFosterParent(element); |
||
6257 | else |
||
6258 | this.attachNode(element, this.openElements.top.node); |
||
6259 | if (!selfClosing) |
||
6260 | this.openElements.push(new StackItem(namespaceURI, name, attributes, element)); |
||
6261 | }; |
||
6262 | |||
6263 | TreeBuilder.prototype.insertFormattingElement = function(name, attributes) { |
||
6264 | this.insertElement(name, attributes, "http://www.w3.org/1999/xhtml"); |
||
6265 | this.appendElementToActiveFormattingElements(this.currentStackItem()); |
||
6266 | }; |
||
6267 | |||
6268 | TreeBuilder.prototype.insertSelfClosingElement = function(name, attributes) { |
||
6269 | this.selfClosingFlagAcknowledged = true; |
||
6270 | this.insertElement(name, attributes, "http://www.w3.org/1999/xhtml", true); |
||
6271 | }; |
||
6272 | |||
6273 | TreeBuilder.prototype.insertForeignElement = function(name, attributes, namespaceURI, selfClosing) { |
||
6274 | if (selfClosing) |
||
6275 | this.selfClosingFlagAcknowledged = true; |
||
6276 | this.insertElement(name, attributes, namespaceURI, selfClosing); |
||
6277 | }; |
||
6278 | |||
6279 | TreeBuilder.prototype.insertComment = function(data, parent) { |
||
6280 | throw new Error("Not implemented"); |
||
6281 | }; |
||
6282 | |||
6283 | TreeBuilder.prototype.insertDoctype = function(name, publicId, systemId) { |
||
6284 | throw new Error("Not implemented"); |
||
6285 | }; |
||
6286 | |||
6287 | TreeBuilder.prototype.insertText = function(data) { |
||
6288 | throw new Error("Not implemented"); |
||
6289 | }; |
||
6290 | TreeBuilder.prototype.currentStackItem = function() { |
||
6291 | return this.openElements.top; |
||
6292 | }; |
||
6293 | TreeBuilder.prototype.popElement = function() { |
||
6294 | return this.openElements.pop(); |
||
6295 | }; |
||
6296 | TreeBuilder.prototype.shouldFosterParent = function() { |
||
6297 | return this.redirectAttachToFosterParent && this.currentStackItem().isFosterParenting(); |
||
6298 | }; |
||
6299 | TreeBuilder.prototype.generateImpliedEndTags = function(exclude) { |
||
6300 | var name = this.openElements.top.localName; |
||
6301 | if (['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'].indexOf(name) != -1 && name != exclude) { |
||
6302 | this.popElement(); |
||
6303 | this.generateImpliedEndTags(exclude); |
||
6304 | } |
||
6305 | }; |
||
6306 | TreeBuilder.prototype.reconstructActiveFormattingElements = function() { |
||
6307 | if (this.activeFormattingElements.length === 0) |
||
6308 | return; |
||
6309 | var i = this.activeFormattingElements.length - 1; |
||
6310 | var entry = this.activeFormattingElements[i]; |
||
6311 | if (entry == Marker || this.openElements.contains(entry)) |
||
6312 | return; |
||
6313 | |||
6314 | while (entry != Marker && !this.openElements.contains(entry)) { |
||
6315 | i -= 1; |
||
6316 | entry = this.activeFormattingElements[i]; |
||
6317 | if (!entry) |
||
6318 | break; |
||
6319 | } |
||
6320 | |||
6321 | while (true) { |
||
6322 | i += 1; |
||
6323 | entry = this.activeFormattingElements[i]; |
||
6324 | this.insertElement(entry.localName, entry.attributes); |
||
6325 | var element = this.currentStackItem(); |
||
6326 | this.activeFormattingElements[i] = element; |
||
6327 | if (element == this.activeFormattingElements[this.activeFormattingElements.length -1]) |
||
6328 | break; |
||
6329 | } |
||
6330 | |||
6331 | }; |
||
6332 | TreeBuilder.prototype.ensureNoahsArkCondition = function(item) { |
||
6333 | var kNoahsArkCapacity = 3; |
||
6334 | if (this.activeFormattingElements.length < kNoahsArkCapacity) |
||
6335 | return; |
||
6336 | var candidates = []; |
||
6337 | var newItemAttributeCount = item.attributes.length; |
||
6338 | for (var i = this.activeFormattingElements.length - 1; i >= 0; i--) { |
||
6339 | var candidate = this.activeFormattingElements[i]; |
||
6340 | if (candidate === Marker) |
||
6341 | break; |
||
6342 | if (item.localName !== candidate.localName || item.namespaceURI !== candidate.namespaceURI) |
||
6343 | continue; |
||
6344 | if (candidate.attributes.length != newItemAttributeCount) |
||
6345 | continue; |
||
6346 | candidates.push(candidate); |
||
6347 | } |
||
6348 | if (candidates.length < kNoahsArkCapacity) |
||
6349 | return; |
||
6350 | |||
6351 | var remainingCandidates = []; |
||
6352 | var attributes = item.attributes; |
||
6353 | for (var i = 0; i < attributes.length; i++) { |
||
6354 | var attribute = attributes[i]; |
||
6355 | |||
6356 | for (var j = 0; j < candidates.length; j++) { |
||
6357 | var candidate = candidates[j]; |
||
6358 | var candidateAttribute = getAttribute(candidate, attribute.nodeName); |
||
6359 | if (candidateAttribute && candidateAttribute.nodeValue === attribute.nodeValue) |
||
6360 | remainingCandidates.push(candidate); |
||
6361 | } |
||
6362 | if (remainingCandidates.length < kNoahsArkCapacity) |
||
6363 | return; |
||
6364 | candidates = remainingCandidates; |
||
6365 | remainingCandidates = []; |
||
6366 | } |
||
6367 | for (var i = kNoahsArkCapacity - 1; i < candidates.length; i++) |
||
6368 | this.removeElementFromActiveFormattingElements(candidates[i]); |
||
6369 | }; |
||
6370 | TreeBuilder.prototype.appendElementToActiveFormattingElements = function(item) { |
||
6371 | this.ensureNoahsArkCondition(item); |
||
6372 | this.activeFormattingElements.push(item); |
||
6373 | }; |
||
6374 | TreeBuilder.prototype.removeElementFromActiveFormattingElements = function(item) { |
||
6375 | var index = this.activeFormattingElements.indexOf(item); |
||
6376 | if (index >= 0) |
||
6377 | this.activeFormattingElements.splice(index, 1); |
||
6378 | }; |
||
6379 | |||
6380 | TreeBuilder.prototype.elementInActiveFormattingElements = function(name) { |
||
6381 | var els = this.activeFormattingElements; |
||
6382 | for (var i = els.length - 1; i >= 0; i--) { |
||
6383 | if (els[i] == Marker) break; |
||
6384 | if (els[i].localName == name) return els[i]; |
||
6385 | } |
||
6386 | return false; |
||
6387 | }; |
||
6388 | |||
6389 | TreeBuilder.prototype.clearActiveFormattingElements = function() { |
||
6390 | while (!(this.activeFormattingElements.length === 0 || this.activeFormattingElements.pop() == Marker)); |
||
6391 | }; |
||
6392 | |||
6393 | TreeBuilder.prototype.reparentChildren = function(oldParent, newParent) { |
||
6394 | throw new Error("Not implemented"); |
||
6395 | }; |
||
6396 | TreeBuilder.prototype.setFragmentContext = function(context) { |
||
6397 | this.context = context; |
||
6398 | }; |
||
6399 | TreeBuilder.prototype.parseError = function(code, args) { |
||
6400 | if (!this.errorHandler) |
||
6401 | return; |
||
6402 | var message = formatMessage(messages[code], args); |
||
6403 | this.errorHandler.error(message, this.tokenizer._inputStream.location(), code); |
||
6404 | }; |
||
6405 | TreeBuilder.prototype.resetInsertionMode = function() { |
||
6406 | var last = false; |
||
6407 | var node = null; |
||
6408 | for (var i = this.openElements.length - 1; i >= 0; i--) { |
||
6409 | node = this.openElements.item(i); |
||
6410 | if (i === 0) { |
||
6411 | assert.ok(this.context); |
||
6412 | last = true; |
||
6413 | node = new StackItem("http://www.w3.org/1999/xhtml", this.context, [], null); |
||
6414 | } |
||
6415 | |||
6416 | if (node.namespaceURI === "http://www.w3.org/1999/xhtml") { |
||
6417 | if (node.localName === 'select') |
||
6418 | return this.setInsertionMode('inSelect'); |
||
6419 | if (node.localName === 'td' || node.localName === 'th') |
||
6420 | return this.setInsertionMode('inCell'); |
||
6421 | if (node.localName === 'tr') |
||
6422 | return this.setInsertionMode('inRow'); |
||
6423 | if (node.localName === 'tbody' || node.localName === 'thead' || node.localName === 'tfoot') |
||
6424 | return this.setInsertionMode('inTableBody'); |
||
6425 | if (node.localName === 'caption') |
||
6426 | return this.setInsertionMode('inCaption'); |
||
6427 | if (node.localName === 'colgroup') |
||
6428 | return this.setInsertionMode('inColumnGroup'); |
||
6429 | if (node.localName === 'table') |
||
6430 | return this.setInsertionMode('inTable'); |
||
6431 | if (node.localName === 'head' && !last) |
||
6432 | return this.setInsertionMode('inHead'); |
||
6433 | if (node.localName === 'body') |
||
6434 | return this.setInsertionMode('inBody'); |
||
6435 | if (node.localName === 'frameset') |
||
6436 | return this.setInsertionMode('inFrameset'); |
||
6437 | if (node.localName === 'html') |
||
6438 | if (!this.openElements.headElement) |
||
6439 | return this.setInsertionMode('beforeHead'); |
||
6440 | else |
||
6441 | return this.setInsertionMode('afterHead'); |
||
6442 | } |
||
6443 | |||
6444 | if (last) |
||
6445 | return this.setInsertionMode('inBody'); |
||
6446 | } |
||
6447 | }; |
||
6448 | |||
6449 | TreeBuilder.prototype.processGenericRCDATAStartTag = function(name, attributes) { |
||
6450 | this.insertElement(name, attributes); |
||
6451 | this.tokenizer.setState(Tokenizer.RCDATA); |
||
6452 | this.originalInsertionMode = this.insertionModeName; |
||
6453 | this.setInsertionMode('text'); |
||
6454 | }; |
||
6455 | |||
6456 | TreeBuilder.prototype.processGenericRawTextStartTag = function(name, attributes) { |
||
6457 | this.insertElement(name, attributes); |
||
6458 | this.tokenizer.setState(Tokenizer.RAWTEXT); |
||
6459 | this.originalInsertionMode = this.insertionModeName; |
||
6460 | this.setInsertionMode('text'); |
||
6461 | }; |
||
6462 | |||
6463 | TreeBuilder.prototype.adjustMathMLAttributes = function(attributes) { |
||
6464 | attributes.forEach(function(a) { |
||
6465 | a.namespaceURI = "http://www.w3.org/1998/Math/MathML"; |
||
6466 | if (constants.MATHMLAttributeMap[a.nodeName]) |
||
6467 | a.nodeName = constants.MATHMLAttributeMap[a.nodeName]; |
||
6468 | }); |
||
6469 | return attributes; |
||
6470 | }; |
||
6471 | |||
6472 | TreeBuilder.prototype.adjustSVGTagNameCase = function(name) { |
||
6473 | return constants.SVGTagMap[name] || name; |
||
6474 | }; |
||
6475 | |||
6476 | TreeBuilder.prototype.adjustSVGAttributes = function(attributes) { |
||
6477 | attributes.forEach(function(a) { |
||
6478 | a.namespaceURI = "http://www.w3.org/2000/svg"; |
||
6479 | if (constants.SVGAttributeMap[a.nodeName]) |
||
6480 | a.nodeName = constants.SVGAttributeMap[a.nodeName]; |
||
6481 | }); |
||
6482 | return attributes; |
||
6483 | }; |
||
6484 | |||
6485 | TreeBuilder.prototype.adjustForeignAttributes = function(attributes) { |
||
6486 | for (var i = 0; i < attributes.length; i++) { |
||
6487 | var attribute = attributes[i]; |
||
6488 | var adjusted = constants.ForeignAttributeMap[attribute.nodeName]; |
||
6489 | if (adjusted) { |
||
6490 | attribute.nodeName = adjusted.localName; |
||
6491 | attribute.prefix = adjusted.prefix; |
||
6492 | attribute.namespaceURI = adjusted.namespaceURI; |
||
6493 | } |
||
6494 | } |
||
6495 | return attributes; |
||
6496 | }; |
||
6497 | |||
6498 | function formatMessage(format, args) { |
||
6499 | return format.replace(new RegExp('{[0-9a-z-]+}', 'gi'), function(match) { |
||
6500 | return args[match.slice(1, -1)] || match; |
||
6501 | }); |
||
6502 | } |
||
6503 | |||
6504 | exports.TreeBuilder = TreeBuilder; |
||
6505 | |||
6506 | }, |
||
6507 | {"./ElementStack":1,"./StackItem":4,"./Tokenizer":5,"./constants":7,"./messages.json":8,"assert":13,"events":16}], |
||
6508 | 7:[function(_dereq_,module,exports){ |
||
6509 | exports.SVGTagMap = { |
||
6510 | "altglyph": "altGlyph", |
||
6511 | "altglyphdef": "altGlyphDef", |
||
6512 | "altglyphitem": "altGlyphItem", |
||
6513 | "animatecolor": "animateColor", |
||
6514 | "animatemotion": "animateMotion", |
||
6515 | "animatetransform": "animateTransform", |
||
6516 | "clippath": "clipPath", |
||
6517 | "feblend": "feBlend", |
||
6518 | "fecolormatrix": "feColorMatrix", |
||
6519 | "fecomponenttransfer": "feComponentTransfer", |
||
6520 | "fecomposite": "feComposite", |
||
6521 | "feconvolvematrix": "feConvolveMatrix", |
||
6522 | "fediffuselighting": "feDiffuseLighting", |
||
6523 | "fedisplacementmap": "feDisplacementMap", |
||
6524 | "fedistantlight": "feDistantLight", |
||
6525 | "feflood": "feFlood", |
||
6526 | "fefunca": "feFuncA", |
||
6527 | "fefuncb": "feFuncB", |
||
6528 | "fefuncg": "feFuncG", |
||
6529 | "fefuncr": "feFuncR", |
||
6530 | "fegaussianblur": "feGaussianBlur", |
||
6531 | "feimage": "feImage", |
||
6532 | "femerge": "feMerge", |
||
6533 | "femergenode": "feMergeNode", |
||
6534 | "femorphology": "feMorphology", |
||
6535 | "feoffset": "feOffset", |
||
6536 | "fepointlight": "fePointLight", |
||
6537 | "fespecularlighting": "feSpecularLighting", |
||
6538 | "fespotlight": "feSpotLight", |
||
6539 | "fetile": "feTile", |
||
6540 | "feturbulence": "feTurbulence", |
||
6541 | "foreignobject": "foreignObject", |
||
6542 | "glyphref": "glyphRef", |
||
6543 | "lineargradient": "linearGradient", |
||
6544 | "radialgradient": "radialGradient", |
||
6545 | "textpath": "textPath" |
||
6546 | }; |
||
6547 | |||
6548 | exports.MATHMLAttributeMap = { |
||
6549 | definitionurl: 'definitionURL' |
||
6550 | }; |
||
6551 | |||
6552 | exports.SVGAttributeMap = { |
||
6553 | attributename: 'attributeName', |
||
6554 | attributetype: 'attributeType', |
||
6555 | basefrequency: 'baseFrequency', |
||
6556 | baseprofile: 'baseProfile', |
||
6557 | calcmode: 'calcMode', |
||
6558 | clippathunits: 'clipPathUnits', |
||
6559 | contentscripttype: 'contentScriptType', |
||
6560 | contentstyletype: 'contentStyleType', |
||
6561 | diffuseconstant: 'diffuseConstant', |
||
6562 | edgemode: 'edgeMode', |
||
6563 | externalresourcesrequired: 'externalResourcesRequired', |
||
6564 | filterres: 'filterRes', |
||
6565 | filterunits: 'filterUnits', |
||
6566 | glyphref: 'glyphRef', |
||
6567 | gradienttransform: 'gradientTransform', |
||
6568 | gradientunits: 'gradientUnits', |
||
6569 | kernelmatrix: 'kernelMatrix', |
||
6570 | kernelunitlength: 'kernelUnitLength', |
||
6571 | keypoints: 'keyPoints', |
||
6572 | keysplines: 'keySplines', |
||
6573 | keytimes: 'keyTimes', |
||
6574 | lengthadjust: 'lengthAdjust', |
||
6575 | limitingconeangle: 'limitingConeAngle', |
||
6576 | markerheight: 'markerHeight', |
||
6577 | markerunits: 'markerUnits', |
||
6578 | markerwidth: 'markerWidth', |
||
6579 | maskcontentunits: 'maskContentUnits', |
||
6580 | maskunits: 'maskUnits', |
||
6581 | numoctaves: 'numOctaves', |
||
6582 | pathlength: 'pathLength', |
||
6583 | patterncontentunits: 'patternContentUnits', |
||
6584 | patterntransform: 'patternTransform', |
||
6585 | patternunits: 'patternUnits', |
||
6586 | pointsatx: 'pointsAtX', |
||
6587 | pointsaty: 'pointsAtY', |
||
6588 | pointsatz: 'pointsAtZ', |
||
6589 | preservealpha: 'preserveAlpha', |
||
6590 | preserveaspectratio: 'preserveAspectRatio', |
||
6591 | primitiveunits: 'primitiveUnits', |
||
6592 | refx: 'refX', |
||
6593 | refy: 'refY', |
||
6594 | repeatcount: 'repeatCount', |
||
6595 | repeatdur: 'repeatDur', |
||
6596 | requiredextensions: 'requiredExtensions', |
||
6597 | requiredfeatures: 'requiredFeatures', |
||
6598 | specularconstant: 'specularConstant', |
||
6599 | specularexponent: 'specularExponent', |
||
6600 | spreadmethod: 'spreadMethod', |
||
6601 | startoffset: 'startOffset', |
||
6602 | stddeviation: 'stdDeviation', |
||
6603 | stitchtiles: 'stitchTiles', |
||
6604 | surfacescale: 'surfaceScale', |
||
6605 | systemlanguage: 'systemLanguage', |
||
6606 | tablevalues: 'tableValues', |
||
6607 | targetx: 'targetX', |
||
6608 | targety: 'targetY', |
||
6609 | textlength: 'textLength', |
||
6610 | viewbox: 'viewBox', |
||
6611 | viewtarget: 'viewTarget', |
||
6612 | xchannelselector: 'xChannelSelector', |
||
6613 | ychannelselector: 'yChannelSelector', |
||
6614 | zoomandpan: 'zoomAndPan' |
||
6615 | }; |
||
6616 | |||
6617 | exports.ForeignAttributeMap = { |
||
6618 | "xlink:actuate": {prefix: "xlink", localName: "actuate", namespaceURI: "http://www.w3.org/1999/xlink"}, |
||
6619 | "xlink:arcrole": {prefix: "xlink", localName: "arcrole", namespaceURI: "http://www.w3.org/1999/xlink"}, |
||
6620 | "xlink:href": {prefix: "xlink", localName: "href", namespaceURI: "http://www.w3.org/1999/xlink"}, |
||
6621 | "xlink:role": {prefix: "xlink", localName: "role", namespaceURI: "http://www.w3.org/1999/xlink"}, |
||
6622 | "xlink:show": {prefix: "xlink", localName: "show", namespaceURI: "http://www.w3.org/1999/xlink"}, |
||
6623 | "xlink:title": {prefix: "xlink", localName: "title", namespaceURI: "http://www.w3.org/1999/xlink"}, |
||
6624 | "xlink:type": {prefix: "xlink", localName: "title", namespaceURI: "http://www.w3.org/1999/xlink"}, |
||
6625 | "xml:base": {prefix: "xml", localName: "base", namespaceURI: "http://www.w3.org/XML/1998/namespace"}, |
||
6626 | "xml:lang": {prefix: "xml", localName: "lang", namespaceURI: "http://www.w3.org/XML/1998/namespace"}, |
||
6627 | "xml:space": {prefix: "xml", localName: "space", namespaceURI: "http://www.w3.org/XML/1998/namespace"}, |
||
6628 | "xmlns": {prefix: null, localName: "xmlns", namespaceURI: "http://www.w3.org/2000/xmlns/"}, |
||
6629 | "xmlns:xlink": {prefix: "xmlns", localName: "xlink", namespaceURI: "http://www.w3.org/2000/xmlns/"}, |
||
6630 | }; |
||
6631 | }, |
||
6632 | {}], |
||
6633 | 8:[function(_dereq_,module,exports){ |
||
6634 | module.exports={ |
||
6635 | "null-character": |
||
6636 | "Null character in input stream, replaced with U+FFFD.", |
||
6637 | "invalid-codepoint": |
||
6638 | "Invalid codepoint in stream", |
||
6639 | "incorrectly-placed-solidus": |
||
6640 | "Solidus (/) incorrectly placed in tag.", |
||
6641 | "incorrect-cr-newline-entity": |
||
6642 | "Incorrect CR newline entity, replaced with LF.", |
||
6643 | "illegal-windows-1252-entity": |
||
6644 | "Entity used with illegal number (windows-1252 reference).", |
||
6645 | "cant-convert-numeric-entity": |
||
6646 | "Numeric entity couldn't be converted to character (codepoint U+{charAsInt}).", |
||
6647 | "invalid-numeric-entity-replaced": |
||
6648 | "Numeric entity represents an illegal codepoint. Expanded to the C1 controls range.", |
||
6649 | "numeric-entity-without-semicolon": |
||
6650 | "Numeric entity didn't end with ';'.", |
||
6651 | "expected-numeric-entity-but-got-eof": |
||
6652 | "Numeric entity expected. Got end of file instead.", |
||
6653 | "expected-numeric-entity": |
||
6654 | "Numeric entity expected but none found.", |
||
6655 | "named-entity-without-semicolon": |
||
6656 | "Named entity didn't end with ';'.", |
||
6657 | "expected-named-entity": |
||
6658 | "Named entity expected. Got none.", |
||
6659 | "attributes-in-end-tag": |
||
6660 | "End tag contains unexpected attributes.", |
||
6661 | "self-closing-flag-on-end-tag": |
||
6662 | "End tag contains unexpected self-closing flag.", |
||
6663 | "bare-less-than-sign-at-eof": |
||
6664 | "End of file after <.", |
||
6665 | "expected-tag-name-but-got-right-bracket": |
||
6666 | "Expected tag name. Got '>' instead.", |
||
6667 | "expected-tag-name-but-got-question-mark": |
||
6668 | "Expected tag name. Got '?' instead. (HTML doesn't support processing instructions.)", |
||
6669 | "expected-tag-name": |
||
6670 | "Expected tag name. Got something else instead.", |
||
6671 | "expected-closing-tag-but-got-right-bracket": |
||
6672 | "Expected closing tag. Got '>' instead. Ignoring '</>'.", |
||
6673 | "expected-closing-tag-but-got-eof": |
||
6674 | "Expected closing tag. Unexpected end of file.", |
||
6675 | "expected-closing-tag-but-got-char": |
||
6676 | "Expected closing tag. Unexpected character '{data}' found.", |
||
6677 | "eof-in-tag-name": |
||
6678 | "Unexpected end of file in the tag name.", |
||
6679 | "expected-attribute-name-but-got-eof": |
||
6680 | "Unexpected end of file. Expected attribute name instead.", |
||
6681 | "eof-in-attribute-name": |
||
6682 | "Unexpected end of file in attribute name.", |
||
6683 | "invalid-character-in-attribute-name": |
||
6684 | "Invalid character in attribute name.", |
||
6685 | "duplicate-attribute": |
||
6686 | "Dropped duplicate attribute '{name}' on tag.", |
||
6687 | "expected-end-of-tag-but-got-eof": |
||
6688 | "Unexpected end of file. Expected = or end of tag.", |
||
6689 | "expected-attribute-value-but-got-eof": |
||
6690 | "Unexpected end of file. Expected attribute value.", |
||
6691 | "expected-attribute-value-but-got-right-bracket": |
||
6692 | "Expected attribute value. Got '>' instead.", |
||
6693 | "unexpected-character-in-unquoted-attribute-value": |
||
6694 | "Unexpected character in unquoted attribute", |
||
6695 | "invalid-character-after-attribute-name": |
||
6696 | "Unexpected character after attribute name.", |
||
6697 | "unexpected-character-after-attribute-value": |
||
6698 | "Unexpected character after attribute value.", |
||
6699 | "eof-in-attribute-value-double-quote": |
||
6700 | "Unexpected end of file in attribute value (\").", |
||
6701 | "eof-in-attribute-value-single-quote": |
||
6702 | "Unexpected end of file in attribute value (').", |
||
6703 | "eof-in-attribute-value-no-quotes": |
||
6704 | "Unexpected end of file in attribute value.", |
||
6705 | "eof-after-attribute-value": |
||
6706 | "Unexpected end of file after attribute value.", |
||
6707 | "unexpected-eof-after-solidus-in-tag": |
||
6708 | "Unexpected end of file in tag. Expected >.", |
||
6709 | "unexpected-character-after-solidus-in-tag": |
||
6710 | "Unexpected character after / in tag. Expected >.", |
||
6711 | "expected-dashes-or-doctype": |
||
6712 | "Expected '--' or 'DOCTYPE'. Not found.", |
||
6713 | "unexpected-bang-after-double-dash-in-comment": |
||
6714 | "Unexpected ! after -- in comment.", |
||
6715 | "incorrect-comment": |
||
6716 | "Incorrect comment.", |
||
6717 | "eof-in-comment": |
||
6718 | "Unexpected end of file in comment.", |
||
6719 | "eof-in-comment-end-dash": |
||
6720 | "Unexpected end of file in comment (-).", |
||
6721 | "unexpected-dash-after-double-dash-in-comment": |
||
6722 | "Unexpected '-' after '--' found in comment.", |
||
6723 | "eof-in-comment-double-dash": |
||
6724 | "Unexpected end of file in comment (--).", |
||
6725 | "eof-in-comment-end-bang-state": |
||
6726 | "Unexpected end of file in comment.", |
||
6727 | "unexpected-char-in-comment": |
||
6728 | "Unexpected character in comment found.", |
||
6729 | "need-space-after-doctype": |
||
6730 | "No space after literal string 'DOCTYPE'.", |
||
6731 | "expected-doctype-name-but-got-right-bracket": |
||
6732 | "Unexpected > character. Expected DOCTYPE name.", |
||
6733 | "expected-doctype-name-but-got-eof": |
||
6734 | "Unexpected end of file. Expected DOCTYPE name.", |
||
6735 | "eof-in-doctype-name": |
||
6736 | "Unexpected end of file in DOCTYPE name.", |
||
6737 | "eof-in-doctype": |
||
6738 | "Unexpected end of file in DOCTYPE.", |
||
6739 | "expected-space-or-right-bracket-in-doctype": |
||
6740 | "Expected space or '>'. Got '{data}'.", |
||
6741 | "unexpected-end-of-doctype": |
||
6742 | "Unexpected end of DOCTYPE.", |
||
6743 | "unexpected-char-in-doctype": |
||
6744 | "Unexpected character in DOCTYPE.", |
||
6745 | "eof-in-bogus-doctype": |
||
6746 | "Unexpected end of file in bogus doctype.", |
||
6747 | "eof-in-innerhtml": |
||
6748 | "Unexpected EOF in inner html mode.", |
||
6749 | "unexpected-doctype": |
||
6750 | "Unexpected DOCTYPE. Ignored.", |
||
6751 | "non-html-root": |
||
6752 | "html needs to be the first start tag.", |
||
6753 | "expected-doctype-but-got-eof": |
||
6754 | "Unexpected End of file. Expected DOCTYPE.", |
||
6755 | "unknown-doctype": |
||
6756 | "Erroneous DOCTYPE. Expected <!DOCTYPE html>.", |
||
6757 | "quirky-doctype": |
||
6758 | "Quirky doctype. Expected <!DOCTYPE html>.", |
||
6759 | "almost-standards-doctype": |
||
6760 | "Almost standards mode doctype. Expected <!DOCTYPE html>.", |
||
6761 | "obsolete-doctype": |
||
6762 | "Obsolete doctype. Expected <!DOCTYPE html>.", |
||
6763 | "expected-doctype-but-got-chars": |
||
6764 | "Non-space characters found without seeing a doctype first. Expected e.g. <!DOCTYPE html>.", |
||
6765 | "expected-doctype-but-got-start-tag": |
||
6766 | "Start tag seen without seeing a doctype first. Expected e.g. <!DOCTYPE html>.", |
||
6767 | "expected-doctype-but-got-end-tag": |
||
6768 | "End tag seen without seeing a doctype first. Expected e.g. <!DOCTYPE html>.", |
||
6769 | "end-tag-after-implied-root": |
||
6770 | "Unexpected end tag ({name}) after the (implied) root element.", |
||
6771 | "expected-named-closing-tag-but-got-eof": |
||
6772 | "Unexpected end of file. Expected end tag ({name}).", |
||
6773 | "two-heads-are-not-better-than-one": |
||
6774 | "Unexpected start tag head in existing head. Ignored.", |
||
6775 | "unexpected-end-tag": |
||
6776 | "Unexpected end tag ({name}). Ignored.", |
||
6777 | "unexpected-implied-end-tag": |
||
6778 | "End tag {name} implied, but there were open elements.", |
||
6779 | "unexpected-start-tag-out-of-my-head": |
||
6780 | "Unexpected start tag ({name}) that can be in head. Moved.", |
||
6781 | "unexpected-start-tag": |
||
6782 | "Unexpected start tag ({name}).", |
||
6783 | "missing-end-tag": |
||
6784 | "Missing end tag ({name}).", |
||
6785 | "missing-end-tags": |
||
6786 | "Missing end tags ({name}).", |
||
6787 | "unexpected-start-tag-implies-end-tag": |
||
6788 | "Unexpected start tag ({startName}) implies end tag ({endName}).", |
||
6789 | "unexpected-start-tag-treated-as": |
||
6790 | "Unexpected start tag ({originalName}). Treated as {newName}.", |
||
6791 | "deprecated-tag": |
||
6792 | "Unexpected start tag {name}. Don't use it!", |
||
6793 | "unexpected-start-tag-ignored": |
||
6794 | "Unexpected start tag {name}. Ignored.", |
||
6795 | "expected-one-end-tag-but-got-another": |
||
6796 | "Unexpected end tag ({gotName}). Missing end tag ({expectedName}).", |
||
6797 | "end-tag-too-early": |
||
6798 | "End tag ({name}) seen too early. Expected other end tag.", |
||
6799 | "end-tag-too-early-named": |
||
6800 | "Unexpected end tag ({gotName}). Expected end tag ({expectedName}.", |
||
6801 | "end-tag-too-early-ignored": |
||
6802 | "End tag ({name}) seen too early. Ignored.", |
||
6803 | "adoption-agency-1.1": |
||
6804 | "End tag ({name}) violates step 1, paragraph 1 of the adoption agency algorithm.", |
||
6805 | "adoption-agency-1.2": |
||
6806 | "End tag ({name}) violates step 1, paragraph 2 of the adoption agency algorithm.", |
||
6807 | "adoption-agency-1.3": |
||
6808 | "End tag ({name}) violates step 1, paragraph 3 of the adoption agency algorithm.", |
||
6809 | "adoption-agency-4.4": |
||
6810 | "End tag ({name}) violates step 4, paragraph 4 of the adoption agency algorithm.", |
||
6811 | "unexpected-end-tag-treated-as": |
||
6812 | "Unexpected end tag ({originalName}). Treated as {newName}.", |
||
6813 | "no-end-tag": |
||
6814 | "This element ({name}) has no end tag.", |
||
6815 | "unexpected-implied-end-tag-in-table": |
||
6816 | "Unexpected implied end tag ({name}) in the table phase.", |
||
6817 | "unexpected-implied-end-tag-in-table-body": |
||
6818 | "Unexpected implied end tag ({name}) in the table body phase.", |
||
6819 | "unexpected-char-implies-table-voodoo": |
||
6820 | "Unexpected non-space characters in table context caused voodoo mode.", |
||
6821 | "unexpected-hidden-input-in-table": |
||
6822 | "Unexpected input with type hidden in table context.", |
||
6823 | "unexpected-form-in-table": |
||
6824 | "Unexpected form in table context.", |
||
6825 | "unexpected-start-tag-implies-table-voodoo": |
||
6826 | "Unexpected start tag ({name}) in table context caused voodoo mode.", |
||
6827 | "unexpected-end-tag-implies-table-voodoo": |
||
6828 | "Unexpected end tag ({name}) in table context caused voodoo mode.", |
||
6829 | "unexpected-cell-in-table-body": |
||
6830 | "Unexpected table cell start tag ({name}) in the table body phase.", |
||
6831 | "unexpected-cell-end-tag": |
||
6832 | "Got table cell end tag ({name}) while required end tags are missing.", |
||
6833 | "unexpected-end-tag-in-table-body": |
||
6834 | "Unexpected end tag ({name}) in the table body phase. Ignored.", |
||
6835 | "unexpected-implied-end-tag-in-table-row": |
||
6836 | "Unexpected implied end tag ({name}) in the table row phase.", |
||
6837 | "unexpected-end-tag-in-table-row": |
||
6838 | "Unexpected end tag ({name}) in the table row phase. Ignored.", |
||
6839 | "unexpected-select-in-select": |
||
6840 | "Unexpected select start tag in the select phase treated as select end tag.", |
||
6841 | "unexpected-input-in-select": |
||
6842 | "Unexpected input start tag in the select phase.", |
||
6843 | "unexpected-start-tag-in-select": |
||
6844 | "Unexpected start tag token ({name}) in the select phase. Ignored.", |
||
6845 | "unexpected-end-tag-in-select": |
||
6846 | "Unexpected end tag ({name}) in the select phase. Ignored.", |
||
6847 | "unexpected-table-element-start-tag-in-select-in-table": |
||
6848 | "Unexpected table element start tag ({name}) in the select in table phase.", |
||
6849 | "unexpected-table-element-end-tag-in-select-in-table": |
||
6850 | "Unexpected table element end tag ({name}) in the select in table phase.", |
||
6851 | "unexpected-char-after-body": |
||
6852 | "Unexpected non-space characters in the after body phase.", |
||
6853 | "unexpected-start-tag-after-body": |
||
6854 | "Unexpected start tag token ({name}) in the after body phase.", |
||
6855 | "unexpected-end-tag-after-body": |
||
6856 | "Unexpected end tag token ({name}) in the after body phase.", |
||
6857 | "unexpected-char-in-frameset": |
||
6858 | "Unepxected characters in the frameset phase. Characters ignored.", |
||
6859 | "unexpected-start-tag-in-frameset": |
||
6860 | "Unexpected start tag token ({name}) in the frameset phase. Ignored.", |
||
6861 | "unexpected-frameset-in-frameset-innerhtml": |
||
6862 | "Unexpected end tag token (frameset in the frameset phase (innerHTML).", |
||
6863 | "unexpected-end-tag-in-frameset": |
||
6864 | "Unexpected end tag token ({name}) in the frameset phase. Ignored.", |
||
6865 | "unexpected-char-after-frameset": |
||
6866 | "Unexpected non-space characters in the after frameset phase. Ignored.", |
||
6867 | "unexpected-start-tag-after-frameset": |
||
6868 | "Unexpected start tag ({name}) in the after frameset phase. Ignored.", |
||
6869 | "unexpected-end-tag-after-frameset": |
||
6870 | "Unexpected end tag ({name}) in the after frameset phase. Ignored.", |
||
6871 | "expected-eof-but-got-char": |
||
6872 | "Unexpected non-space characters. Expected end of file.", |
||
6873 | "expected-eof-but-got-start-tag": |
||
6874 | "Unexpected start tag ({name}). Expected end of file.", |
||
6875 | "expected-eof-but-got-end-tag": |
||
6876 | "Unexpected end tag ({name}). Expected end of file.", |
||
6877 | "unexpected-end-table-in-caption": |
||
6878 | "Unexpected end table tag in caption. Generates implied end caption.", |
||
6879 | "end-html-in-innerhtml": |
||
6880 | "Unexpected html end tag in inner html mode.", |
||
6881 | "eof-in-table": |
||
6882 | "Unexpected end of file. Expected table content.", |
||
6883 | "eof-in-script": |
||
6884 | "Unexpected end of file. Expected script content.", |
||
6885 | "non-void-element-with-trailing-solidus": |
||
6886 | "Trailing solidus not allowed on element {name}.", |
||
6887 | "unexpected-html-element-in-foreign-content": |
||
6888 | "HTML start tag \"{name}\" in a foreign namespace context.", |
||
6889 | "unexpected-start-tag-in-table": |
||
6890 | "Unexpected {name}. Expected table content." |
||
6891 | } |
||
6892 | }, |
||
6893 | {}], |
||
6894 | 9:[function(_dereq_,module,exports){ |
||
6895 | var SAXTreeBuilder = _dereq_('./SAXTreeBuilder').SAXTreeBuilder; |
||
6896 | var Tokenizer = _dereq_('../Tokenizer').Tokenizer; |
||
6897 | var TreeParser = _dereq_('./TreeParser').TreeParser; |
||
6898 | |||
6899 | function SAXParser() { |
||
6900 | this.contentHandler = null; |
||
6901 | this._errorHandler = null; |
||
6902 | this._treeBuilder = new SAXTreeBuilder(); |
||
6903 | this._tokenizer = new Tokenizer(this._treeBuilder); |
||
6904 | this._scriptingEnabled = false; |
||
6905 | } |
||
6906 | |||
6907 | SAXParser.prototype.parse = function(source) { |
||
6908 | this._tokenizer.tokenize(source); |
||
6909 | var document = this._treeBuilder.document; |
||
6910 | if (document) { |
||
6911 | new TreeParser(this.contentHandler).parse(document); |
||
6912 | } |
||
6913 | }; |
||
6914 | |||
6915 | SAXParser.prototype.parseFragment = function(source, context) { |
||
6916 | this._treeBuilder.setFragmentContext(context); |
||
6917 | this._tokenizer.tokenize(source); |
||
6918 | var fragment = this._treeBuilder.getFragment(); |
||
6919 | if (fragment) { |
||
6920 | new TreeParser(this.contentHandler).parse(fragment); |
||
6921 | } |
||
6922 | }; |
||
6923 | |||
6924 | Object.defineProperty(SAXParser.prototype, 'scriptingEnabled', { |
||
6925 | get: function() { |
||
6926 | return this._scriptingEnabled; |
||
6927 | }, |
||
6928 | set: function(value) { |
||
6929 | this._scriptingEnabled = value; |
||
6930 | this._treeBuilder.scriptingEnabled = value; |
||
6931 | } |
||
6932 | }); |
||
6933 | |||
6934 | Object.defineProperty(SAXParser.prototype, 'errorHandler', { |
||
6935 | get: function() { |
||
6936 | return this._errorHandler; |
||
6937 | }, |
||
6938 | set: function(value) { |
||
6939 | this._errorHandler = value; |
||
6940 | this._treeBuilder.errorHandler = value; |
||
6941 | } |
||
6942 | }); |
||
6943 | |||
6944 | exports.SAXParser = SAXParser; |
||
6945 | |||
6946 | }, |
||
6947 | {"../Tokenizer":5,"./SAXTreeBuilder":10,"./TreeParser":11}], |
||
6948 | 10:[function(_dereq_,module,exports){ |
||
6949 | var util = _dereq_('util'); |
||
6950 | var TreeBuilder = _dereq_('../TreeBuilder').TreeBuilder; |
||
6951 | |||
6952 | function SAXTreeBuilder() { |
||
6953 | TreeBuilder.call(this); |
||
6954 | } |
||
6955 | |||
6956 | util.inherits(SAXTreeBuilder, TreeBuilder); |
||
6957 | |||
6958 | SAXTreeBuilder.prototype.start = function(tokenizer) { |
||
6959 | this.document = new Document(this.tokenizer); |
||
6960 | }; |
||
6961 | |||
6962 | SAXTreeBuilder.prototype.end = function() { |
||
6963 | this.document.endLocator = this.tokenizer; |
||
6964 | }; |
||
6965 | |||
6966 | SAXTreeBuilder.prototype.insertDoctype = function(name, publicId, systemId) { |
||
6967 | var doctype = new DTD(this.tokenizer, name, publicId, systemId); |
||
6968 | doctype.endLocator = this.tokenizer; |
||
6969 | this.document.appendChild(doctype); |
||
6970 | }; |
||
6971 | |||
6972 | SAXTreeBuilder.prototype.createElement = function(namespaceURI, localName, attributes) { |
||
6973 | var element = new Element(this.tokenizer, namespaceURI, localName, localName, attributes || []); |
||
6974 | return element; |
||
6975 | }; |
||
6976 | |||
6977 | SAXTreeBuilder.prototype.insertComment = function(data, parent) { |
||
6978 | if (!parent) |
||
6979 | parent = this.currentStackItem(); |
||
6980 | var comment = new Comment(this.tokenizer, data); |
||
6981 | parent.appendChild(comment); |
||
6982 | }; |
||
6983 | |||
6984 | SAXTreeBuilder.prototype.appendCharacters = function(parent, data) { |
||
6985 | var text = new Characters(this.tokenizer, data); |
||
6986 | parent.appendChild(text); |
||
6987 | }; |
||
6988 | |||
6989 | SAXTreeBuilder.prototype.insertText = function(data) { |
||
6990 | if (this.redirectAttachToFosterParent && this.openElements.top.isFosterParenting()) { |
||
6991 | var tableIndex = this.openElements.findIndex('table'); |
||
6992 | var tableItem = this.openElements.item(tableIndex); |
||
6993 | var table = tableItem.node; |
||
6994 | if (tableIndex === 0) { |
||
6995 | return this.appendCharacters(table, data); |
||
6996 | } |
||
6997 | var text = new Characters(this.tokenizer, data); |
||
6998 | var parent = table.parentNode; |
||
6999 | if (parent) { |
||
7000 | parent.insertBetween(text, table.previousSibling, table); |
||
7001 | return; |
||
7002 | } |
||
7003 | var stackParent = this.openElements.item(tableIndex - 1).node; |
||
7004 | stackParent.appendChild(text); |
||
7005 | return; |
||
7006 | } |
||
7007 | this.appendCharacters(this.currentStackItem().node, data); |
||
7008 | }; |
||
7009 | |||
7010 | SAXTreeBuilder.prototype.attachNode = function(node, parent) { |
||
7011 | parent.appendChild(node); |
||
7012 | }; |
||
7013 | |||
7014 | SAXTreeBuilder.prototype.attachNodeToFosterParent = function(child, table, stackParent) { |
||
7015 | var parent = table.parentNode; |
||
7016 | if (parent) |
||
7017 | parent.insertBetween(child, table.previousSibling, table); |
||
7018 | else |
||
7019 | stackParent.appendChild(child); |
||
7020 | }; |
||
7021 | |||
7022 | SAXTreeBuilder.prototype.detachFromParent = function(element) { |
||
7023 | element.detach(); |
||
7024 | }; |
||
7025 | |||
7026 | SAXTreeBuilder.prototype.reparentChildren = function(oldParent, newParent) { |
||
7027 | newParent.appendChildren(oldParent.firstChild); |
||
7028 | }; |
||
7029 | |||
7030 | SAXTreeBuilder.prototype.getFragment = function() { |
||
7031 | var fragment = new DocumentFragment(); |
||
7032 | this.reparentChildren(this.openElements.rootNode, fragment); |
||
7033 | return fragment; |
||
7034 | }; |
||
7035 | |||
7036 | function getAttribute(node, name) { |
||
7037 | for (var i = 0; i < node.attributes.length; i++) { |
||
7038 | var attribute = node.attributes[i]; |
||
7039 | if (attribute.nodeName === name) |
||
7040 | return attribute.nodeValue; |
||
7041 | } |
||
7042 | } |
||
7043 | |||
7044 | SAXTreeBuilder.prototype.addAttributesToElement = function(element, attributes) { |
||
7045 | for (var i = 0; i < attributes.length; i++) { |
||
7046 | var attribute = attributes[i]; |
||
7047 | if (!getAttribute(element, attribute.nodeName)) |
||
7048 | element.attributes.push(attribute); |
||
7049 | } |
||
7050 | }; |
||
7051 | |||
7052 | var NodeType = { |
||
7053 | CDATA: 1, |
||
7054 | CHARACTERS: 2, |
||
7055 | COMMENT: 3, |
||
7056 | DOCUMENT: 4, |
||
7057 | DOCUMENT_FRAGMENT: 5, |
||
7058 | DTD: 6, |
||
7059 | ELEMENT: 7, |
||
7060 | ENTITY: 8, |
||
7061 | IGNORABLE_WHITESPACE: 9, |
||
7062 | PROCESSING_INSTRUCTION: 10, |
||
7063 | SKIPPED_ENTITY: 11 |
||
7064 | }; |
||
7065 | function Node(locator) { |
||
7066 | if (!locator) { |
||
7067 | this.columnNumber = -1; |
||
7068 | this.lineNumber = -1; |
||
7069 | } else { |
||
7070 | this.columnNumber = locator.columnNumber; |
||
7071 | this.lineNumber = locator.lineNumber; |
||
7072 | } |
||
7073 | this.parentNode = null; |
||
7074 | this.nextSibling = null; |
||
7075 | this.firstChild = null; |
||
7076 | } |
||
7077 | Node.prototype.visit = function(treeParser) { |
||
7078 | throw new Error("Not Implemented"); |
||
7079 | }; |
||
7080 | Node.prototype.revisit = function(treeParser) { |
||
7081 | return; |
||
7082 | }; |
||
7083 | Node.prototype.detach = function() { |
||
7084 | if (this.parentNode !== null) { |
||
7085 | this.parentNode.removeChild(this); |
||
7086 | this.parentNode = null; |
||
7087 | } |
||
7088 | }; |
||
7089 | |||
7090 | Object.defineProperty(Node.prototype, 'previousSibling', { |
||
7091 | get: function() { |
||
7092 | var prev = null; |
||
7093 | var next = this.parentNode.firstChild; |
||
7094 | for(;;) { |
||
7095 | if (this == next) { |
||
7096 | return prev; |
||
7097 | } |
||
7098 | prev = next; |
||
7099 | next = next.nextSibling; |
||
7100 | } |
||
7101 | } |
||
7102 | }); |
||
7103 | |||
7104 | |||
7105 | function ParentNode(locator) { |
||
7106 | Node.call(this, locator); |
||
7107 | this.lastChild = null; |
||
7108 | this._endLocator = null; |
||
7109 | } |
||
7110 | |||
7111 | ParentNode.prototype = Object.create(Node.prototype); |
||
7112 | ParentNode.prototype.insertBefore = function(child, sibling) { |
||
7113 | if (!sibling) { |
||
7114 | return this.appendChild(child); |
||
7115 | } |
||
7116 | child.detach(); |
||
7117 | child.parentNode = this; |
||
7118 | if (this.firstChild == sibling) { |
||
7119 | child.nextSibling = sibling; |
||
7120 | this.firstChild = child; |
||
7121 | } else { |
||
7122 | var prev = this.firstChild; |
||
7123 | var next = this.firstChild.nextSibling; |
||
7124 | while (next != sibling) { |
||
7125 | prev = next; |
||
7126 | next = next.nextSibling; |
||
7127 | } |
||
7128 | prev.nextSibling = child; |
||
7129 | child.nextSibling = next; |
||
7130 | } |
||
7131 | return child; |
||
7132 | }; |
||
7133 | |||
7134 | ParentNode.prototype.insertBetween = function(child, prev, next) { |
||
7135 | if (!next) { |
||
7136 | return this.appendChild(child); |
||
7137 | } |
||
7138 | child.detach(); |
||
7139 | child.parentNode = this; |
||
7140 | child.nextSibling = next; |
||
7141 | if (!prev) { |
||
7142 | firstChild = child; |
||
7143 | } else { |
||
7144 | prev.nextSibling = child; |
||
7145 | } |
||
7146 | return child; |
||
7147 | }; |
||
7148 | ParentNode.prototype.appendChild = function(child) { |
||
7149 | child.detach(); |
||
7150 | child.parentNode = this; |
||
7151 | if (!this.firstChild) { |
||
7152 | this.firstChild = child; |
||
7153 | } else { |
||
7154 | this.lastChild.nextSibling = child; |
||
7155 | } |
||
7156 | this.lastChild = child; |
||
7157 | return child; |
||
7158 | }; |
||
7159 | ParentNode.prototype.appendChildren = function(parent) { |
||
7160 | var child = parent.firstChild; |
||
7161 | if (!child) { |
||
7162 | return; |
||
7163 | } |
||
7164 | var another = parent; |
||
7165 | if (!this.firstChild) { |
||
7166 | this.firstChild = child; |
||
7167 | } else { |
||
7168 | this.lastChild.nextSibling = child; |
||
7169 | } |
||
7170 | this.lastChild = another.lastChild; |
||
7171 | do { |
||
7172 | child.parentNode = this; |
||
7173 | } while ((child = child.nextSibling)); |
||
7174 | another.firstChild = null; |
||
7175 | another.lastChild = null; |
||
7176 | }; |
||
7177 | ParentNode.prototype.removeChild = function(node) { |
||
7178 | if (this.firstChild == node) { |
||
7179 | this.firstChild = node.nextSibling; |
||
7180 | if (this.lastChild == node) { |
||
7181 | this.lastChild = null; |
||
7182 | } |
||
7183 | } else { |
||
7184 | var prev = this.firstChild; |
||
7185 | var next = this.firstChild.nextSibling; |
||
7186 | while (next != node) { |
||
7187 | prev = next; |
||
7188 | next = next.nextSibling; |
||
7189 | } |
||
7190 | prev.nextSibling = node.nextSibling; |
||
7191 | if (this.lastChild == node) { |
||
7192 | this.lastChild = prev; |
||
7193 | } |
||
7194 | } |
||
7195 | node.parentNode = null; |
||
7196 | return node; |
||
7197 | }; |
||
7198 | |||
7199 | Object.defineProperty(ParentNode.prototype, 'endLocator', { |
||
7200 | get: function() { |
||
7201 | return this._endLocator; |
||
7202 | }, |
||
7203 | set: function(endLocator) { |
||
7204 | this._endLocator = { |
||
7205 | lineNumber: endLocator.lineNumber, |
||
7206 | columnNumber: endLocator.columnNumber |
||
7207 | }; |
||
7208 | } |
||
7209 | }); |
||
7210 | function Document (locator) { |
||
7211 | ParentNode.call(this, locator); |
||
7212 | this.nodeType = NodeType.DOCUMENT; |
||
7213 | } |
||
7214 | |||
7215 | Document.prototype = Object.create(ParentNode.prototype); |
||
7216 | Document.prototype.visit = function(treeParser) { |
||
7217 | treeParser.startDocument(this); |
||
7218 | }; |
||
7219 | Document.prototype.revisit = function(treeParser) { |
||
7220 | treeParser.endDocument(this.endLocator); |
||
7221 | }; |
||
7222 | function DocumentFragment() { |
||
7223 | ParentNode.call(this, new Locator()); |
||
7224 | this.nodeType = NodeType.DOCUMENT_FRAGMENT; |
||
7225 | } |
||
7226 | |||
7227 | DocumentFragment.prototype = Object.create(ParentNode.prototype); |
||
7228 | DocumentFragment.prototype.visit = function(treeParser) { |
||
7229 | }; |
||
7230 | function Element(locator, uri, localName, qName, atts, prefixMappings) { |
||
7231 | ParentNode.call(this, locator); |
||
7232 | this.uri = uri; |
||
7233 | this.localName = localName; |
||
7234 | this.qName = qName; |
||
7235 | this.attributes = atts; |
||
7236 | this.prefixMappings = prefixMappings; |
||
7237 | this.nodeType = NodeType.ELEMENT; |
||
7238 | } |
||
7239 | |||
7240 | Element.prototype = Object.create(ParentNode.prototype); |
||
7241 | Element.prototype.visit = function(treeParser) { |
||
7242 | if (this.prefixMappings) { |
||
7243 | for (var key in prefixMappings) { |
||
7244 | var mapping = prefixMappings[key]; |
||
7245 | treeParser.startPrefixMapping(mapping.getPrefix(), |
||
7246 | mapping.getUri(), this); |
||
7247 | } |
||
7248 | } |
||
7249 | treeParser.startElement(this.uri, this.localName, this.qName, this.attributes, this); |
||
7250 | }; |
||
7251 | Element.prototype.revisit = function(treeParser) { |
||
7252 | treeParser.endElement(this.uri, this.localName, this.qName, this.endLocator); |
||
7253 | if (this.prefixMappings) { |
||
7254 | for (var key in prefixMappings) { |
||
7255 | var mapping = prefixMappings[key]; |
||
7256 | treeParser.endPrefixMapping(mapping.getPrefix(), this.endLocator); |
||
7257 | } |
||
7258 | } |
||
7259 | }; |
||
7260 | function Characters(locator, data){ |
||
7261 | Node.call(this, locator); |
||
7262 | this.data = data; |
||
7263 | this.nodeType = NodeType.CHARACTERS; |
||
7264 | } |
||
7265 | |||
7266 | Characters.prototype = Object.create(Node.prototype); |
||
7267 | Characters.prototype.visit = function (treeParser) { |
||
7268 | treeParser.characters(this.data, 0, this.data.length, this); |
||
7269 | }; |
||
7270 | function IgnorableWhitespace(locator, data) { |
||
7271 | Node.call(this, locator); |
||
7272 | this.data = data; |
||
7273 | this.nodeType = NodeType.IGNORABLE_WHITESPACE; |
||
7274 | } |
||
7275 | |||
7276 | IgnorableWhitespace.prototype = Object.create(Node.prototype); |
||
7277 | IgnorableWhitespace.prototype.visit = function(treeParser) { |
||
7278 | treeParser.ignorableWhitespace(this.data, 0, this.data.length, this); |
||
7279 | }; |
||
7280 | function Comment(locator, data) { |
||
7281 | Node.call(this, locator); |
||
7282 | this.data = data; |
||
7283 | this.nodeType = NodeType.COMMENT; |
||
7284 | } |
||
7285 | |||
7286 | Comment.prototype = Object.create(Node.prototype); |
||
7287 | Comment.prototype.visit = function(treeParser) { |
||
7288 | treeParser.comment(this.data, 0, this.data.length, this); |
||
7289 | }; |
||
7290 | function CDATA(locator) { |
||
7291 | ParentNode.call(this, locator); |
||
7292 | this.nodeType = NodeType.CDATA; |
||
7293 | } |
||
7294 | |||
7295 | CDATA.prototype = Object.create(ParentNode.prototype); |
||
7296 | CDATA.prototype.visit = function(treeParser) { |
||
7297 | treeParser.startCDATA(this); |
||
7298 | }; |
||
7299 | CDATA.prototype.revisit = function(treeParser) { |
||
7300 | treeParser.endCDATA(this.endLocator); |
||
7301 | }; |
||
7302 | function Entity(name) { |
||
7303 | ParentNode.call(this); |
||
7304 | this.name = name; |
||
7305 | this.nodeType = NodeType.ENTITY; |
||
7306 | } |
||
7307 | |||
7308 | Entity.prototype = Object.create(ParentNode.prototype); |
||
7309 | Entity.prototype.visit = function(treeParser) { |
||
7310 | treeParser.startEntity(this.name, this); |
||
7311 | }; |
||
7312 | Entity.prototype.revisit = function(treeParser) { |
||
7313 | treeParser.endEntity(this.name); |
||
7314 | }; |
||
7315 | |||
7316 | function SkippedEntity(name) { |
||
7317 | Node.call(this); |
||
7318 | this.name = name; |
||
7319 | this.nodeType = NodeType.SKIPPED_ENTITY; |
||
7320 | } |
||
7321 | |||
7322 | SkippedEntity.prototype = Object.create(Node.prototype); |
||
7323 | SkippedEntity.prototype.visit = function(treeParser) { |
||
7324 | treeParser.skippedEntity(this.name, this); |
||
7325 | }; |
||
7326 | function ProcessingInstruction(target, data) { |
||
7327 | Node.call(this); |
||
7328 | this.target = target; |
||
7329 | this.data = data; |
||
7330 | } |
||
7331 | |||
7332 | ProcessingInstruction.prototype = Object.create(Node.prototype); |
||
7333 | ProcessingInstruction.prototype.visit = function(treeParser) { |
||
7334 | treeParser.processingInstruction(this.target, this.data, this); |
||
7335 | }; |
||
7336 | ProcessingInstruction.prototype.getNodeType = function() { |
||
7337 | return NodeType.PROCESSING_INSTRUCTION; |
||
7338 | }; |
||
7339 | function DTD(name, publicIdentifier, systemIdentifier) { |
||
7340 | ParentNode.call(this); |
||
7341 | this.name = name; |
||
7342 | this.publicIdentifier = publicIdentifier; |
||
7343 | this.systemIdentifier = systemIdentifier; |
||
7344 | this.nodeType = NodeType.DTD; |
||
7345 | } |
||
7346 | |||
7347 | DTD.prototype = Object.create(ParentNode.prototype); |
||
7348 | DTD.prototype.visit = function(treeParser) { |
||
7349 | treeParser.startDTD(this.name, this.publicIdentifier, this.systemIdentifier, this); |
||
7350 | }; |
||
7351 | DTD.prototype.revisit = function(treeParser) { |
||
7352 | treeParser.endDTD(); |
||
7353 | }; |
||
7354 | |||
7355 | exports.SAXTreeBuilder = SAXTreeBuilder; |
||
7356 | |||
7357 | }, |
||
7358 | {"../TreeBuilder":6,"util":20}], |
||
7359 | 11:[function(_dereq_,module,exports){ |
||
7360 | function TreeParser(contentHandler, lexicalHandler){ |
||
7361 | this.contentHandler; |
||
7362 | this.lexicalHandler; |
||
7363 | this.locatorDelegate; |
||
7364 | |||
7365 | if (!contentHandler) { |
||
7366 | throw new IllegalArgumentException("contentHandler was null."); |
||
7367 | } |
||
7368 | this.contentHandler = contentHandler; |
||
7369 | if (!lexicalHandler) { |
||
7370 | this.lexicalHandler = new NullLexicalHandler(); |
||
7371 | } else { |
||
7372 | this.lexicalHandler = lexicalHandler; |
||
7373 | } |
||
7374 | } |
||
7375 | TreeParser.prototype.parse = function(node) { |
||
7376 | this.contentHandler.documentLocator = this; |
||
7377 | var current = node; |
||
7378 | var next; |
||
7379 | for (;;) { |
||
7380 | current.visit(this); |
||
7381 | if (next = current.firstChild) { |
||
7382 | current = next; |
||
7383 | continue; |
||
7384 | } |
||
7385 | for (;;) { |
||
7386 | current.revisit(this); |
||
7387 | if (current == node) { |
||
7388 | return; |
||
7389 | } |
||
7390 | if (next = current.nextSibling) { |
||
7391 | current = next; |
||
7392 | break; |
||
7393 | } |
||
7394 | current = current.parentNode; |
||
7395 | } |
||
7396 | } |
||
7397 | }; |
||
7398 | TreeParser.prototype.characters = function(ch, start, length, locator) { |
||
7399 | this.locatorDelegate = locator; |
||
7400 | this.contentHandler.characters(ch, start, length); |
||
7401 | }; |
||
7402 | TreeParser.prototype.endDocument = function(locator) { |
||
7403 | this.locatorDelegate = locator; |
||
7404 | this.contentHandler.endDocument(); |
||
7405 | }; |
||
7406 | TreeParser.prototype.endElement = function(uri, localName, qName, locator) { |
||
7407 | this.locatorDelegate = locator; |
||
7408 | this.contentHandler.endElement(uri, localName, qName); |
||
7409 | }; |
||
7410 | TreeParser.prototype.endPrefixMapping = function(prefix, locator) { |
||
7411 | this.locatorDelegate = locator; |
||
7412 | this.contentHandler.endPrefixMapping(prefix); |
||
7413 | }; |
||
7414 | TreeParser.prototype.ignorableWhitespace = function(ch, start, length, locator) { |
||
7415 | this.locatorDelegate = locator; |
||
7416 | this.contentHandler.ignorableWhitespace(ch, start, length); |
||
7417 | }; |
||
7418 | TreeParser.prototype.processingInstruction = function(target, data, locator) { |
||
7419 | this.locatorDelegate = locator; |
||
7420 | this.contentHandler.processingInstruction(target, data); |
||
7421 | }; |
||
7422 | TreeParser.prototype.skippedEntity = function(name, locator) { |
||
7423 | this.locatorDelegate = locator; |
||
7424 | this.contentHandler.skippedEntity(name); |
||
7425 | }; |
||
7426 | TreeParser.prototype.startDocument = function(locator) { |
||
7427 | this.locatorDelegate = locator; |
||
7428 | this.contentHandler.startDocument(); |
||
7429 | }; |
||
7430 | TreeParser.prototype.startElement = function(uri, localName, qName, atts, locator) { |
||
7431 | this.locatorDelegate = locator; |
||
7432 | this.contentHandler.startElement(uri, localName, qName, atts); |
||
7433 | }; |
||
7434 | TreeParser.prototype.startPrefixMapping = function(prefix, uri, locator) { |
||
7435 | this.locatorDelegate = locator; |
||
7436 | this.contentHandler.startPrefixMapping(prefix, uri); |
||
7437 | }; |
||
7438 | TreeParser.prototype.comment = function(ch, start, length, locator) { |
||
7439 | this.locatorDelegate = locator; |
||
7440 | this.lexicalHandler.comment(ch, start, length); |
||
7441 | }; |
||
7442 | TreeParser.prototype.endCDATA = function(locator) { |
||
7443 | this.locatorDelegate = locator; |
||
7444 | this.lexicalHandler.endCDATA(); |
||
7445 | }; |
||
7446 | TreeParser.prototype.endDTD = function(locator) { |
||
7447 | this.locatorDelegate = locator; |
||
7448 | this.lexicalHandler.endDTD(); |
||
7449 | }; |
||
7450 | TreeParser.prototype.endEntity = function(name, locator) { |
||
7451 | this.locatorDelegate = locator; |
||
7452 | this.lexicalHandler.endEntity(name); |
||
7453 | }; |
||
7454 | TreeParser.prototype.startCDATA = function(locator) { |
||
7455 | this.locatorDelegate = locator; |
||
7456 | this.lexicalHandler.startCDATA(); |
||
7457 | }; |
||
7458 | TreeParser.prototype.startDTD = function(name, publicId, systemId, locator) { |
||
7459 | this.locatorDelegate = locator; |
||
7460 | this.lexicalHandler.startDTD(name, publicId, systemId); |
||
7461 | }; |
||
7462 | TreeParser.prototype.startEntity = function(name, locator) { |
||
7463 | this.locatorDelegate = locator; |
||
7464 | this.lexicalHandler.startEntity(name); |
||
7465 | }; |
||
7466 | |||
7467 | Object.defineProperty(TreeParser.prototype, 'columnNumber', { |
||
7468 | get: function() { |
||
7469 | if (!this.locatorDelegate) |
||
7470 | return -1; |
||
7471 | else |
||
7472 | return this.locatorDelegate.columnNumber; |
||
7473 | } |
||
7474 | }); |
||
7475 | |||
7476 | Object.defineProperty(TreeParser.prototype, 'lineNumber', { |
||
7477 | get: function() { |
||
7478 | if (!this.locatorDelegate) |
||
7479 | return -1; |
||
7480 | else |
||
7481 | return this.locatorDelegate.lineNumber; |
||
7482 | } |
||
7483 | }); |
||
7484 | function NullLexicalHandler() { |
||
7485 | |||
7486 | } |
||
7487 | |||
7488 | NullLexicalHandler.prototype.comment = function() {}; |
||
7489 | NullLexicalHandler.prototype.endCDATA = function() {}; |
||
7490 | NullLexicalHandler.prototype.endDTD = function() {}; |
||
7491 | NullLexicalHandler.prototype.endEntity = function() {}; |
||
7492 | NullLexicalHandler.prototype.startCDATA = function() {}; |
||
7493 | NullLexicalHandler.prototype.startDTD = function() {}; |
||
7494 | NullLexicalHandler.prototype.startEntity = function() {}; |
||
7495 | |||
7496 | exports.TreeParser = TreeParser; |
||
7497 | |||
7498 | }, |
||
7499 | {}], |
||
7500 | 12:[function(_dereq_,module,exports){ |
||
7501 | module.exports = { |
||
7502 | "Aacute;": "\u00C1", |
||
7503 | "Aacute": "\u00C1", |
||
7504 | "aacute;": "\u00E1", |
||
7505 | "aacute": "\u00E1", |
||
7506 | "Abreve;": "\u0102", |
||
7507 | "abreve;": "\u0103", |
||
7508 | "ac;": "\u223E", |
||
7509 | "acd;": "\u223F", |
||
7510 | "acE;": "\u223E\u0333", |
||
7511 | "Acirc;": "\u00C2", |
||
7512 | "Acirc": "\u00C2", |
||
7513 | "acirc;": "\u00E2", |
||
7514 | "acirc": "\u00E2", |
||
7515 | "acute;": "\u00B4", |
||
7516 | "acute": "\u00B4", |
||
7517 | "Acy;": "\u0410", |
||
7518 | "acy;": "\u0430", |
||
7519 | "AElig;": "\u00C6", |
||
7520 | "AElig": "\u00C6", |
||
7521 | "aelig;": "\u00E6", |
||
7522 | "aelig": "\u00E6", |
||
7523 | "af;": "\u2061", |
||
7524 | "Afr;": "\uD835\uDD04", |
||
7525 | "afr;": "\uD835\uDD1E", |
||
7526 | "Agrave;": "\u00C0", |
||
7527 | "Agrave": "\u00C0", |
||
7528 | "agrave;": "\u00E0", |
||
7529 | "agrave": "\u00E0", |
||
7530 | "alefsym;": "\u2135", |
||
7531 | "aleph;": "\u2135", |
||
7532 | "Alpha;": "\u0391", |
||
7533 | "alpha;": "\u03B1", |
||
7534 | "Amacr;": "\u0100", |
||
7535 | "amacr;": "\u0101", |
||
7536 | "amalg;": "\u2A3F", |
||
7537 | "amp;": "\u0026", |
||
7538 | "amp": "\u0026", |
||
7539 | "AMP;": "\u0026", |
||
7540 | "AMP": "\u0026", |
||
7541 | "andand;": "\u2A55", |
||
7542 | "And;": "\u2A53", |
||
7543 | "and;": "\u2227", |
||
7544 | "andd;": "\u2A5C", |
||
7545 | "andslope;": "\u2A58", |
||
7546 | "andv;": "\u2A5A", |
||
7547 | "ang;": "\u2220", |
||
7548 | "ange;": "\u29A4", |
||
7549 | "angle;": "\u2220", |
||
7550 | "angmsdaa;": "\u29A8", |
||
7551 | "angmsdab;": "\u29A9", |
||
7552 | "angmsdac;": "\u29AA", |
||
7553 | "angmsdad;": "\u29AB", |
||
7554 | "angmsdae;": "\u29AC", |
||
7555 | "angmsdaf;": "\u29AD", |
||
7556 | "angmsdag;": "\u29AE", |
||
7557 | "angmsdah;": "\u29AF", |
||
7558 | "angmsd;": "\u2221", |
||
7559 | "angrt;": "\u221F", |
||
7560 | "angrtvb;": "\u22BE", |
||
7561 | "angrtvbd;": "\u299D", |
||
7562 | "angsph;": "\u2222", |
||
7563 | "angst;": "\u00C5", |
||
7564 | "angzarr;": "\u237C", |
||
7565 | "Aogon;": "\u0104", |
||
7566 | "aogon;": "\u0105", |
||
7567 | "Aopf;": "\uD835\uDD38", |
||
7568 | "aopf;": "\uD835\uDD52", |
||
7569 | "apacir;": "\u2A6F", |
||
7570 | "ap;": "\u2248", |
||
7571 | "apE;": "\u2A70", |
||
7572 | "ape;": "\u224A", |
||
7573 | "apid;": "\u224B", |
||
7574 | "apos;": "\u0027", |
||
7575 | "ApplyFunction;": "\u2061", |
||
7576 | "approx;": "\u2248", |
||
7577 | "approxeq;": "\u224A", |
||
7578 | "Aring;": "\u00C5", |
||
7579 | "Aring": "\u00C5", |
||
7580 | "aring;": "\u00E5", |
||
7581 | "aring": "\u00E5", |
||
7582 | "Ascr;": "\uD835\uDC9C", |
||
7583 | "ascr;": "\uD835\uDCB6", |
||
7584 | "Assign;": "\u2254", |
||
7585 | "ast;": "\u002A", |
||
7586 | "asymp;": "\u2248", |
||
7587 | "asympeq;": "\u224D", |
||
7588 | "Atilde;": "\u00C3", |
||
7589 | "Atilde": "\u00C3", |
||
7590 | "atilde;": "\u00E3", |
||
7591 | "atilde": "\u00E3", |
||
7592 | "Auml;": "\u00C4", |
||
7593 | "Auml": "\u00C4", |
||
7594 | "auml;": "\u00E4", |
||
7595 | "auml": "\u00E4", |
||
7596 | "awconint;": "\u2233", |
||
7597 | "awint;": "\u2A11", |
||
7598 | "backcong;": "\u224C", |
||
7599 | "backepsilon;": "\u03F6", |
||
7600 | "backprime;": "\u2035", |
||
7601 | "backsim;": "\u223D", |
||
7602 | "backsimeq;": "\u22CD", |
||
7603 | "Backslash;": "\u2216", |
||
7604 | "Barv;": "\u2AE7", |
||
7605 | "barvee;": "\u22BD", |
||
7606 | "barwed;": "\u2305", |
||
7607 | "Barwed;": "\u2306", |
||
7608 | "barwedge;": "\u2305", |
||
7609 | "bbrk;": "\u23B5", |
||
7610 | "bbrktbrk;": "\u23B6", |
||
7611 | "bcong;": "\u224C", |
||
7612 | "Bcy;": "\u0411", |
||
7613 | "bcy;": "\u0431", |
||
7614 | "bdquo;": "\u201E", |
||
7615 | "becaus;": "\u2235", |
||
7616 | "because;": "\u2235", |
||
7617 | "Because;": "\u2235", |
||
7618 | "bemptyv;": "\u29B0", |
||
7619 | "bepsi;": "\u03F6", |
||
7620 | "bernou;": "\u212C", |
||
7621 | "Bernoullis;": "\u212C", |
||
7622 | "Beta;": "\u0392", |
||
7623 | "beta;": "\u03B2", |
||
7624 | "beth;": "\u2136", |
||
7625 | "between;": "\u226C", |
||
7626 | "Bfr;": "\uD835\uDD05", |
||
7627 | "bfr;": "\uD835\uDD1F", |
||
7628 | "bigcap;": "\u22C2", |
||
7629 | "bigcirc;": "\u25EF", |
||
7630 | "bigcup;": "\u22C3", |
||
7631 | "bigodot;": "\u2A00", |
||
7632 | "bigoplus;": "\u2A01", |
||
7633 | "bigotimes;": "\u2A02", |
||
7634 | "bigsqcup;": "\u2A06", |
||
7635 | "bigstar;": "\u2605", |
||
7636 | "bigtriangledown;": "\u25BD", |
||
7637 | "bigtriangleup;": "\u25B3", |
||
7638 | "biguplus;": "\u2A04", |
||
7639 | "bigvee;": "\u22C1", |
||
7640 | "bigwedge;": "\u22C0", |
||
7641 | "bkarow;": "\u290D", |
||
7642 | "blacklozenge;": "\u29EB", |
||
7643 | "blacksquare;": "\u25AA", |
||
7644 | "blacktriangle;": "\u25B4", |
||
7645 | "blacktriangledown;": "\u25BE", |
||
7646 | "blacktriangleleft;": "\u25C2", |
||
7647 | "blacktriangleright;": "\u25B8", |
||
7648 | "blank;": "\u2423", |
||
7649 | "blk12;": "\u2592", |
||
7650 | "blk14;": "\u2591", |
||
7651 | "blk34;": "\u2593", |
||
7652 | "block;": "\u2588", |
||
7653 | "bne;": "\u003D\u20E5", |
||
7654 | "bnequiv;": "\u2261\u20E5", |
||
7655 | "bNot;": "\u2AED", |
||
7656 | "bnot;": "\u2310", |
||
7657 | "Bopf;": "\uD835\uDD39", |
||
7658 | "bopf;": "\uD835\uDD53", |
||
7659 | "bot;": "\u22A5", |
||
7660 | "bottom;": "\u22A5", |
||
7661 | "bowtie;": "\u22C8", |
||
7662 | "boxbox;": "\u29C9", |
||
7663 | "boxdl;": "\u2510", |
||
7664 | "boxdL;": "\u2555", |
||
7665 | "boxDl;": "\u2556", |
||
7666 | "boxDL;": "\u2557", |
||
7667 | "boxdr;": "\u250C", |
||
7668 | "boxdR;": "\u2552", |
||
7669 | "boxDr;": "\u2553", |
||
7670 | "boxDR;": "\u2554", |
||
7671 | "boxh;": "\u2500", |
||
7672 | "boxH;": "\u2550", |
||
7673 | "boxhd;": "\u252C", |
||
7674 | "boxHd;": "\u2564", |
||
7675 | "boxhD;": "\u2565", |
||
7676 | "boxHD;": "\u2566", |
||
7677 | "boxhu;": "\u2534", |
||
7678 | "boxHu;": "\u2567", |
||
7679 | "boxhU;": "\u2568", |
||
7680 | "boxHU;": "\u2569", |
||
7681 | "boxminus;": "\u229F", |
||
7682 | "boxplus;": "\u229E", |
||
7683 | "boxtimes;": "\u22A0", |
||
7684 | "boxul;": "\u2518", |
||
7685 | "boxuL;": "\u255B", |
||
7686 | "boxUl;": "\u255C", |
||
7687 | "boxUL;": "\u255D", |
||
7688 | "boxur;": "\u2514", |
||
7689 | "boxuR;": "\u2558", |
||
7690 | "boxUr;": "\u2559", |
||
7691 | "boxUR;": "\u255A", |
||
7692 | "boxv;": "\u2502", |
||
7693 | "boxV;": "\u2551", |
||
7694 | "boxvh;": "\u253C", |
||
7695 | "boxvH;": "\u256A", |
||
7696 | "boxVh;": "\u256B", |
||
7697 | "boxVH;": "\u256C", |
||
7698 | "boxvl;": "\u2524", |
||
7699 | "boxvL;": "\u2561", |
||
7700 | "boxVl;": "\u2562", |
||
7701 | "boxVL;": "\u2563", |
||
7702 | "boxvr;": "\u251C", |
||
7703 | "boxvR;": "\u255E", |
||
7704 | "boxVr;": "\u255F", |
||
7705 | "boxVR;": "\u2560", |
||
7706 | "bprime;": "\u2035", |
||
7707 | "breve;": "\u02D8", |
||
7708 | "Breve;": "\u02D8", |
||
7709 | "brvbar;": "\u00A6", |
||
7710 | "brvbar": "\u00A6", |
||
7711 | "bscr;": "\uD835\uDCB7", |
||
7712 | "Bscr;": "\u212C", |
||
7713 | "bsemi;": "\u204F", |
||
7714 | "bsim;": "\u223D", |
||
7715 | "bsime;": "\u22CD", |
||
7716 | "bsolb;": "\u29C5", |
||
7717 | "bsol;": "\u005C", |
||
7718 | "bsolhsub;": "\u27C8", |
||
7719 | "bull;": "\u2022", |
||
7720 | "bullet;": "\u2022", |
||
7721 | "bump;": "\u224E", |
||
7722 | "bumpE;": "\u2AAE", |
||
7723 | "bumpe;": "\u224F", |
||
7724 | "Bumpeq;": "\u224E", |
||
7725 | "bumpeq;": "\u224F", |
||
7726 | "Cacute;": "\u0106", |
||
7727 | "cacute;": "\u0107", |
||
7728 | "capand;": "\u2A44", |
||
7729 | "capbrcup;": "\u2A49", |
||
7730 | "capcap;": "\u2A4B", |
||
7731 | "cap;": "\u2229", |
||
7732 | "Cap;": "\u22D2", |
||
7733 | "capcup;": "\u2A47", |
||
7734 | "capdot;": "\u2A40", |
||
7735 | "CapitalDifferentialD;": "\u2145", |
||
7736 | "caps;": "\u2229\uFE00", |
||
7737 | "caret;": "\u2041", |
||
7738 | "caron;": "\u02C7", |
||
7739 | "Cayleys;": "\u212D", |
||
7740 | "ccaps;": "\u2A4D", |
||
7741 | "Ccaron;": "\u010C", |
||
7742 | "ccaron;": "\u010D", |
||
7743 | "Ccedil;": "\u00C7", |
||
7744 | "Ccedil": "\u00C7", |
||
7745 | "ccedil;": "\u00E7", |
||
7746 | "ccedil": "\u00E7", |
||
7747 | "Ccirc;": "\u0108", |
||
7748 | "ccirc;": "\u0109", |
||
7749 | "Cconint;": "\u2230", |
||
7750 | "ccups;": "\u2A4C", |
||
7751 | "ccupssm;": "\u2A50", |
||
7752 | "Cdot;": "\u010A", |
||
7753 | "cdot;": "\u010B", |
||
7754 | "cedil;": "\u00B8", |
||
7755 | "cedil": "\u00B8", |
||
7756 | "Cedilla;": "\u00B8", |
||
7757 | "cemptyv;": "\u29B2", |
||
7758 | "cent;": "\u00A2", |
||
7759 | "cent": "\u00A2", |
||
7760 | "centerdot;": "\u00B7", |
||
7761 | "CenterDot;": "\u00B7", |
||
7762 | "cfr;": "\uD835\uDD20", |
||
7763 | "Cfr;": "\u212D", |
||
7764 | "CHcy;": "\u0427", |
||
7765 | "chcy;": "\u0447", |
||
7766 | "check;": "\u2713", |
||
7767 | "checkmark;": "\u2713", |
||
7768 | "Chi;": "\u03A7", |
||
7769 | "chi;": "\u03C7", |
||
7770 | "circ;": "\u02C6", |
||
7771 | "circeq;": "\u2257", |
||
7772 | "circlearrowleft;": "\u21BA", |
||
7773 | "circlearrowright;": "\u21BB", |
||
7774 | "circledast;": "\u229B", |
||
7775 | "circledcirc;": "\u229A", |
||
7776 | "circleddash;": "\u229D", |
||
7777 | "CircleDot;": "\u2299", |
||
7778 | "circledR;": "\u00AE", |
||
7779 | "circledS;": "\u24C8", |
||
7780 | "CircleMinus;": "\u2296", |
||
7781 | "CirclePlus;": "\u2295", |
||
7782 | "CircleTimes;": "\u2297", |
||
7783 | "cir;": "\u25CB", |
||
7784 | "cirE;": "\u29C3", |
||
7785 | "cire;": "\u2257", |
||
7786 | "cirfnint;": "\u2A10", |
||
7787 | "cirmid;": "\u2AEF", |
||
7788 | "cirscir;": "\u29C2", |
||
7789 | "ClockwiseContourIntegral;": "\u2232", |
||
7790 | "CloseCurlyDoubleQuote;": "\u201D", |
||
7791 | "CloseCurlyQuote;": "\u2019", |
||
7792 | "clubs;": "\u2663", |
||
7793 | "clubsuit;": "\u2663", |
||
7794 | "colon;": "\u003A", |
||
7795 | "Colon;": "\u2237", |
||
7796 | "Colone;": "\u2A74", |
||
7797 | "colone;": "\u2254", |
||
7798 | "coloneq;": "\u2254", |
||
7799 | "comma;": "\u002C", |
||
7800 | "commat;": "\u0040", |
||
7801 | "comp;": "\u2201", |
||
7802 | "compfn;": "\u2218", |
||
7803 | "complement;": "\u2201", |
||
7804 | "complexes;": "\u2102", |
||
7805 | "cong;": "\u2245", |
||
7806 | "congdot;": "\u2A6D", |
||
7807 | "Congruent;": "\u2261", |
||
7808 | "conint;": "\u222E", |
||
7809 | "Conint;": "\u222F", |
||
7810 | "ContourIntegral;": "\u222E", |
||
7811 | "copf;": "\uD835\uDD54", |
||
7812 | "Copf;": "\u2102", |
||
7813 | "coprod;": "\u2210", |
||
7814 | "Coproduct;": "\u2210", |
||
7815 | "copy;": "\u00A9", |
||
7816 | "copy": "\u00A9", |
||
7817 | "COPY;": "\u00A9", |
||
7818 | "COPY": "\u00A9", |
||
7819 | "copysr;": "\u2117", |
||
7820 | "CounterClockwiseContourIntegral;": "\u2233", |
||
7821 | "crarr;": "\u21B5", |
||
7822 | "cross;": "\u2717", |
||
7823 | "Cross;": "\u2A2F", |
||
7824 | "Cscr;": "\uD835\uDC9E", |
||
7825 | "cscr;": "\uD835\uDCB8", |
||
7826 | "csub;": "\u2ACF", |
||
7827 | "csube;": "\u2AD1", |
||
7828 | "csup;": "\u2AD0", |
||
7829 | "csupe;": "\u2AD2", |
||
7830 | "ctdot;": "\u22EF", |
||
7831 | "cudarrl;": "\u2938", |
||
7832 | "cudarrr;": "\u2935", |
||
7833 | "cuepr;": "\u22DE", |
||
7834 | "cuesc;": "\u22DF", |
||
7835 | "cularr;": "\u21B6", |
||
7836 | "cularrp;": "\u293D", |
||
7837 | "cupbrcap;": "\u2A48", |
||
7838 | "cupcap;": "\u2A46", |
||
7839 | "CupCap;": "\u224D", |
||
7840 | "cup;": "\u222A", |
||
7841 | "Cup;": "\u22D3", |
||
7842 | "cupcup;": "\u2A4A", |
||
7843 | "cupdot;": "\u228D", |
||
7844 | "cupor;": "\u2A45", |
||
7845 | "cups;": "\u222A\uFE00", |
||
7846 | "curarr;": "\u21B7", |
||
7847 | "curarrm;": "\u293C", |
||
7848 | "curlyeqprec;": "\u22DE", |
||
7849 | "curlyeqsucc;": "\u22DF", |
||
7850 | "curlyvee;": "\u22CE", |
||
7851 | "curlywedge;": "\u22CF", |
||
7852 | "curren;": "\u00A4", |
||
7853 | "curren": "\u00A4", |
||
7854 | "curvearrowleft;": "\u21B6", |
||
7855 | "curvearrowright;": "\u21B7", |
||
7856 | "cuvee;": "\u22CE", |
||
7857 | "cuwed;": "\u22CF", |
||
7858 | "cwconint;": "\u2232", |
||
7859 | "cwint;": "\u2231", |
||
7860 | "cylcty;": "\u232D", |
||
7861 | "dagger;": "\u2020", |
||
7862 | "Dagger;": "\u2021", |
||
7863 | "daleth;": "\u2138", |
||
7864 | "darr;": "\u2193", |
||
7865 | "Darr;": "\u21A1", |
||
7866 | "dArr;": "\u21D3", |
||
7867 | "dash;": "\u2010", |
||
7868 | "Dashv;": "\u2AE4", |
||
7869 | "dashv;": "\u22A3", |
||
7870 | "dbkarow;": "\u290F", |
||
7871 | "dblac;": "\u02DD", |
||
7872 | "Dcaron;": "\u010E", |
||
7873 | "dcaron;": "\u010F", |
||
7874 | "Dcy;": "\u0414", |
||
7875 | "dcy;": "\u0434", |
||
7876 | "ddagger;": "\u2021", |
||
7877 | "ddarr;": "\u21CA", |
||
7878 | "DD;": "\u2145", |
||
7879 | "dd;": "\u2146", |
||
7880 | "DDotrahd;": "\u2911", |
||
7881 | "ddotseq;": "\u2A77", |
||
7882 | "deg;": "\u00B0", |
||
7883 | "deg": "\u00B0", |
||
7884 | "Del;": "\u2207", |
||
7885 | "Delta;": "\u0394", |
||
7886 | "delta;": "\u03B4", |
||
7887 | "demptyv;": "\u29B1", |
||
7888 | "dfisht;": "\u297F", |
||
7889 | "Dfr;": "\uD835\uDD07", |
||
7890 | "dfr;": "\uD835\uDD21", |
||
7891 | "dHar;": "\u2965", |
||
7892 | "dharl;": "\u21C3", |
||
7893 | "dharr;": "\u21C2", |
||
7894 | "DiacriticalAcute;": "\u00B4", |
||
7895 | "DiacriticalDot;": "\u02D9", |
||
7896 | "DiacriticalDoubleAcute;": "\u02DD", |
||
7897 | "DiacriticalGrave;": "\u0060", |
||
7898 | "DiacriticalTilde;": "\u02DC", |
||
7899 | "diam;": "\u22C4", |
||
7900 | "diamond;": "\u22C4", |
||
7901 | "Diamond;": "\u22C4", |
||
7902 | "diamondsuit;": "\u2666", |
||
7903 | "diams;": "\u2666", |
||
7904 | "die;": "\u00A8", |
||
7905 | "DifferentialD;": "\u2146", |
||
7906 | "digamma;": "\u03DD", |
||
7907 | "disin;": "\u22F2", |
||
7908 | "div;": "\u00F7", |
||
7909 | "divide;": "\u00F7", |
||
7910 | "divide": "\u00F7", |
||
7911 | "divideontimes;": "\u22C7", |
||
7912 | "divonx;": "\u22C7", |
||
7913 | "DJcy;": "\u0402", |
||
7914 | "djcy;": "\u0452", |
||
7915 | "dlcorn;": "\u231E", |
||
7916 | "dlcrop;": "\u230D", |
||
7917 | "dollar;": "\u0024", |
||
7918 | "Dopf;": "\uD835\uDD3B", |
||
7919 | "dopf;": "\uD835\uDD55", |
||
7920 | "Dot;": "\u00A8", |
||
7921 | "dot;": "\u02D9", |
||
7922 | "DotDot;": "\u20DC", |
||
7923 | "doteq;": "\u2250", |
||
7924 | "doteqdot;": "\u2251", |
||
7925 | "DotEqual;": "\u2250", |
||
7926 | "dotminus;": "\u2238", |
||
7927 | "dotplus;": "\u2214", |
||
7928 | "dotsquare;": "\u22A1", |
||
7929 | "doublebarwedge;": "\u2306", |
||
7930 | "DoubleContourIntegral;": "\u222F", |
||
7931 | "DoubleDot;": "\u00A8", |
||
7932 | "DoubleDownArrow;": "\u21D3", |
||
7933 | "DoubleLeftArrow;": "\u21D0", |
||
7934 | "DoubleLeftRightArrow;": "\u21D4", |
||
7935 | "DoubleLeftTee;": "\u2AE4", |
||
7936 | "DoubleLongLeftArrow;": "\u27F8", |
||
7937 | "DoubleLongLeftRightArrow;": "\u27FA", |
||
7938 | "DoubleLongRightArrow;": "\u27F9", |
||
7939 | "DoubleRightArrow;": "\u21D2", |
||
7940 | "DoubleRightTee;": "\u22A8", |
||
7941 | "DoubleUpArrow;": "\u21D1", |
||
7942 | "DoubleUpDownArrow;": "\u21D5", |
||
7943 | "DoubleVerticalBar;": "\u2225", |
||
7944 | "DownArrowBar;": "\u2913", |
||
7945 | "downarrow;": "\u2193", |
||
7946 | "DownArrow;": "\u2193", |
||
7947 | "Downarrow;": "\u21D3", |
||
7948 | "DownArrowUpArrow;": "\u21F5", |
||
7949 | "DownBreve;": "\u0311", |
||
7950 | "downdownarrows;": "\u21CA", |
||
7951 | "downharpoonleft;": "\u21C3", |
||
7952 | "downharpoonright;": "\u21C2", |
||
7953 | "DownLeftRightVector;": "\u2950", |
||
7954 | "DownLeftTeeVector;": "\u295E", |
||
7955 | "DownLeftVectorBar;": "\u2956", |
||
7956 | "DownLeftVector;": "\u21BD", |
||
7957 | "DownRightTeeVector;": "\u295F", |
||
7958 | "DownRightVectorBar;": "\u2957", |
||
7959 | "DownRightVector;": "\u21C1", |
||
7960 | "DownTeeArrow;": "\u21A7", |
||
7961 | "DownTee;": "\u22A4", |
||
7962 | "drbkarow;": "\u2910", |
||
7963 | "drcorn;": "\u231F", |
||
7964 | "drcrop;": "\u230C", |
||
7965 | "Dscr;": "\uD835\uDC9F", |
||
7966 | "dscr;": "\uD835\uDCB9", |
||
7967 | "DScy;": "\u0405", |
||
7968 | "dscy;": "\u0455", |
||
7969 | "dsol;": "\u29F6", |
||
7970 | "Dstrok;": "\u0110", |
||
7971 | "dstrok;": "\u0111", |
||
7972 | "dtdot;": "\u22F1", |
||
7973 | "dtri;": "\u25BF", |
||
7974 | "dtrif;": "\u25BE", |
||
7975 | "duarr;": "\u21F5", |
||
7976 | "duhar;": "\u296F", |
||
7977 | "dwangle;": "\u29A6", |
||
7978 | "DZcy;": "\u040F", |
||
7979 | "dzcy;": "\u045F", |
||
7980 | "dzigrarr;": "\u27FF", |
||
7981 | "Eacute;": "\u00C9", |
||
7982 | "Eacute": "\u00C9", |
||
7983 | "eacute;": "\u00E9", |
||
7984 | "eacute": "\u00E9", |
||
7985 | "easter;": "\u2A6E", |
||
7986 | "Ecaron;": "\u011A", |
||
7987 | "ecaron;": "\u011B", |
||
7988 | "Ecirc;": "\u00CA", |
||
7989 | "Ecirc": "\u00CA", |
||
7990 | "ecirc;": "\u00EA", |
||
7991 | "ecirc": "\u00EA", |
||
7992 | "ecir;": "\u2256", |
||
7993 | "ecolon;": "\u2255", |
||
7994 | "Ecy;": "\u042D", |
||
7995 | "ecy;": "\u044D", |
||
7996 | "eDDot;": "\u2A77", |
||
7997 | "Edot;": "\u0116", |
||
7998 | "edot;": "\u0117", |
||
7999 | "eDot;": "\u2251", |
||
8000 | "ee;": "\u2147", |
||
8001 | "efDot;": "\u2252", |
||
8002 | "Efr;": "\uD835\uDD08", |
||
8003 | "efr;": "\uD835\uDD22", |
||
8004 | "eg;": "\u2A9A", |
||
8005 | "Egrave;": "\u00C8", |
||
8006 | "Egrave": "\u00C8", |
||
8007 | "egrave;": "\u00E8", |
||
8008 | "egrave": "\u00E8", |
||
8009 | "egs;": "\u2A96", |
||
8010 | "egsdot;": "\u2A98", |
||
8011 | "el;": "\u2A99", |
||
8012 | "Element;": "\u2208", |
||
8013 | "elinters;": "\u23E7", |
||
8014 | "ell;": "\u2113", |
||
8015 | "els;": "\u2A95", |
||
8016 | "elsdot;": "\u2A97", |
||
8017 | "Emacr;": "\u0112", |
||
8018 | "emacr;": "\u0113", |
||
8019 | "empty;": "\u2205", |
||
8020 | "emptyset;": "\u2205", |
||
8021 | "EmptySmallSquare;": "\u25FB", |
||
8022 | "emptyv;": "\u2205", |
||
8023 | "EmptyVerySmallSquare;": "\u25AB", |
||
8024 | "emsp13;": "\u2004", |
||
8025 | "emsp14;": "\u2005", |
||
8026 | "emsp;": "\u2003", |
||
8027 | "ENG;": "\u014A", |
||
8028 | "eng;": "\u014B", |
||
8029 | "ensp;": "\u2002", |
||
8030 | "Eogon;": "\u0118", |
||
8031 | "eogon;": "\u0119", |
||
8032 | "Eopf;": "\uD835\uDD3C", |
||
8033 | "eopf;": "\uD835\uDD56", |
||
8034 | "epar;": "\u22D5", |
||
8035 | "eparsl;": "\u29E3", |
||
8036 | "eplus;": "\u2A71", |
||
8037 | "epsi;": "\u03B5", |
||
8038 | "Epsilon;": "\u0395", |
||
8039 | "epsilon;": "\u03B5", |
||
8040 | "epsiv;": "\u03F5", |
||
8041 | "eqcirc;": "\u2256", |
||
8042 | "eqcolon;": "\u2255", |
||
8043 | "eqsim;": "\u2242", |
||
8044 | "eqslantgtr;": "\u2A96", |
||
8045 | "eqslantless;": "\u2A95", |
||
8046 | "Equal;": "\u2A75", |
||
8047 | "equals;": "\u003D", |
||
8048 | "EqualTilde;": "\u2242", |
||
8049 | "equest;": "\u225F", |
||
8050 | "Equilibrium;": "\u21CC", |
||
8051 | "equiv;": "\u2261", |
||
8052 | "equivDD;": "\u2A78", |
||
8053 | "eqvparsl;": "\u29E5", |
||
8054 | "erarr;": "\u2971", |
||
8055 | "erDot;": "\u2253", |
||
8056 | "escr;": "\u212F", |
||
8057 | "Escr;": "\u2130", |
||
8058 | "esdot;": "\u2250", |
||
8059 | "Esim;": "\u2A73", |
||
8060 | "esim;": "\u2242", |
||
8061 | "Eta;": "\u0397", |
||
8062 | "eta;": "\u03B7", |
||
8063 | "ETH;": "\u00D0", |
||
8064 | "ETH": "\u00D0", |
||
8065 | "eth;": "\u00F0", |
||
8066 | "eth": "\u00F0", |
||
8067 | "Euml;": "\u00CB", |
||
8068 | "Euml": "\u00CB", |
||
8069 | "euml;": "\u00EB", |
||
8070 | "euml": "\u00EB", |
||
8071 | "euro;": "\u20AC", |
||
8072 | "excl;": "\u0021", |
||
8073 | "exist;": "\u2203", |
||
8074 | "Exists;": "\u2203", |
||
8075 | "expectation;": "\u2130", |
||
8076 | "exponentiale;": "\u2147", |
||
8077 | "ExponentialE;": "\u2147", |
||
8078 | "fallingdotseq;": "\u2252", |
||
8079 | "Fcy;": "\u0424", |
||
8080 | "fcy;": "\u0444", |
||
8081 | "female;": "\u2640", |
||
8082 | "ffilig;": "\uFB03", |
||
8083 | "fflig;": "\uFB00", |
||
8084 | "ffllig;": "\uFB04", |
||
8085 | "Ffr;": "\uD835\uDD09", |
||
8086 | "ffr;": "\uD835\uDD23", |
||
8087 | "filig;": "\uFB01", |
||
8088 | "FilledSmallSquare;": "\u25FC", |
||
8089 | "FilledVerySmallSquare;": "\u25AA", |
||
8090 | "fjlig;": "\u0066\u006A", |
||
8091 | "flat;": "\u266D", |
||
8092 | "fllig;": "\uFB02", |
||
8093 | "fltns;": "\u25B1", |
||
8094 | "fnof;": "\u0192", |
||
8095 | "Fopf;": "\uD835\uDD3D", |
||
8096 | "fopf;": "\uD835\uDD57", |
||
8097 | "forall;": "\u2200", |
||
8098 | "ForAll;": "\u2200", |
||
8099 | "fork;": "\u22D4", |
||
8100 | "forkv;": "\u2AD9", |
||
8101 | "Fouriertrf;": "\u2131", |
||
8102 | "fpartint;": "\u2A0D", |
||
8103 | "frac12;": "\u00BD", |
||
8104 | "frac12": "\u00BD", |
||
8105 | "frac13;": "\u2153", |
||
8106 | "frac14;": "\u00BC", |
||
8107 | "frac14": "\u00BC", |
||
8108 | "frac15;": "\u2155", |
||
8109 | "frac16;": "\u2159", |
||
8110 | "frac18;": "\u215B", |
||
8111 | "frac23;": "\u2154", |
||
8112 | "frac25;": "\u2156", |
||
8113 | "frac34;": "\u00BE", |
||
8114 | "frac34": "\u00BE", |
||
8115 | "frac35;": "\u2157", |
||
8116 | "frac38;": "\u215C", |
||
8117 | "frac45;": "\u2158", |
||
8118 | "frac56;": "\u215A", |
||
8119 | "frac58;": "\u215D", |
||
8120 | "frac78;": "\u215E", |
||
8121 | "frasl;": "\u2044", |
||
8122 | "frown;": "\u2322", |
||
8123 | "fscr;": "\uD835\uDCBB", |
||
8124 | "Fscr;": "\u2131", |
||
8125 | "gacute;": "\u01F5", |
||
8126 | "Gamma;": "\u0393", |
||
8127 | "gamma;": "\u03B3", |
||
8128 | "Gammad;": "\u03DC", |
||
8129 | "gammad;": "\u03DD", |
||
8130 | "gap;": "\u2A86", |
||
8131 | "Gbreve;": "\u011E", |
||
8132 | "gbreve;": "\u011F", |
||
8133 | "Gcedil;": "\u0122", |
||
8134 | "Gcirc;": "\u011C", |
||
8135 | "gcirc;": "\u011D", |
||
8136 | "Gcy;": "\u0413", |
||
8137 | "gcy;": "\u0433", |
||
8138 | "Gdot;": "\u0120", |
||
8139 | "gdot;": "\u0121", |
||
8140 | "ge;": "\u2265", |
||
8141 | "gE;": "\u2267", |
||
8142 | "gEl;": "\u2A8C", |
||
8143 | "gel;": "\u22DB", |
||
8144 | "geq;": "\u2265", |
||
8145 | "geqq;": "\u2267", |
||
8146 | "geqslant;": "\u2A7E", |
||
8147 | "gescc;": "\u2AA9", |
||
8148 | "ges;": "\u2A7E", |
||
8149 | "gesdot;": "\u2A80", |
||
8150 | "gesdoto;": "\u2A82", |
||
8151 | "gesdotol;": "\u2A84", |
||
8152 | "gesl;": "\u22DB\uFE00", |
||
8153 | "gesles;": "\u2A94", |
||
8154 | "Gfr;": "\uD835\uDD0A", |
||
8155 | "gfr;": "\uD835\uDD24", |
||
8156 | "gg;": "\u226B", |
||
8157 | "Gg;": "\u22D9", |
||
8158 | "ggg;": "\u22D9", |
||
8159 | "gimel;": "\u2137", |
||
8160 | "GJcy;": "\u0403", |
||
8161 | "gjcy;": "\u0453", |
||
8162 | "gla;": "\u2AA5", |
||
8163 | "gl;": "\u2277", |
||
8164 | "glE;": "\u2A92", |
||
8165 | "glj;": "\u2AA4", |
||
8166 | "gnap;": "\u2A8A", |
||
8167 | "gnapprox;": "\u2A8A", |
||
8168 | "gne;": "\u2A88", |
||
8169 | "gnE;": "\u2269", |
||
8170 | "gneq;": "\u2A88", |
||
8171 | "gneqq;": "\u2269", |
||
8172 | "gnsim;": "\u22E7", |
||
8173 | "Gopf;": "\uD835\uDD3E", |
||
8174 | "gopf;": "\uD835\uDD58", |
||
8175 | "grave;": "\u0060", |
||
8176 | "GreaterEqual;": "\u2265", |
||
8177 | "GreaterEqualLess;": "\u22DB", |
||
8178 | "GreaterFullEqual;": "\u2267", |
||
8179 | "GreaterGreater;": "\u2AA2", |
||
8180 | "GreaterLess;": "\u2277", |
||
8181 | "GreaterSlantEqual;": "\u2A7E", |
||
8182 | "GreaterTilde;": "\u2273", |
||
8183 | "Gscr;": "\uD835\uDCA2", |
||
8184 | "gscr;": "\u210A", |
||
8185 | "gsim;": "\u2273", |
||
8186 | "gsime;": "\u2A8E", |
||
8187 | "gsiml;": "\u2A90", |
||
8188 | "gtcc;": "\u2AA7", |
||
8189 | "gtcir;": "\u2A7A", |
||
8190 | "gt;": "\u003E", |
||
8191 | "gt": "\u003E", |
||
8192 | "GT;": "\u003E", |
||
8193 | "GT": "\u003E", |
||
8194 | "Gt;": "\u226B", |
||
8195 | "gtdot;": "\u22D7", |
||
8196 | "gtlPar;": "\u2995", |
||
8197 | "gtquest;": "\u2A7C", |
||
8198 | "gtrapprox;": "\u2A86", |
||
8199 | "gtrarr;": "\u2978", |
||
8200 | "gtrdot;": "\u22D7", |
||
8201 | "gtreqless;": "\u22DB", |
||
8202 | "gtreqqless;": "\u2A8C", |
||
8203 | "gtrless;": "\u2277", |
||
8204 | "gtrsim;": "\u2273", |
||
8205 | "gvertneqq;": "\u2269\uFE00", |
||
8206 | "gvnE;": "\u2269\uFE00", |
||
8207 | "Hacek;": "\u02C7", |
||
8208 | "hairsp;": "\u200A", |
||
8209 | "half;": "\u00BD", |
||
8210 | "hamilt;": "\u210B", |
||
8211 | "HARDcy;": "\u042A", |
||
8212 | "hardcy;": "\u044A", |
||
8213 | "harrcir;": "\u2948", |
||
8214 | "harr;": "\u2194", |
||
8215 | "hArr;": "\u21D4", |
||
8216 | "harrw;": "\u21AD", |
||
8217 | "Hat;": "\u005E", |
||
8218 | "hbar;": "\u210F", |
||
8219 | "Hcirc;": "\u0124", |
||
8220 | "hcirc;": "\u0125", |
||
8221 | "hearts;": "\u2665", |
||
8222 | "heartsuit;": "\u2665", |
||
8223 | "hellip;": "\u2026", |
||
8224 | "hercon;": "\u22B9", |
||
8225 | "hfr;": "\uD835\uDD25", |
||
8226 | "Hfr;": "\u210C", |
||
8227 | "HilbertSpace;": "\u210B", |
||
8228 | "hksearow;": "\u2925", |
||
8229 | "hkswarow;": "\u2926", |
||
8230 | "hoarr;": "\u21FF", |
||
8231 | "homtht;": "\u223B", |
||
8232 | "hookleftarrow;": "\u21A9", |
||
8233 | "hookrightarrow;": "\u21AA", |
||
8234 | "hopf;": "\uD835\uDD59", |
||
8235 | "Hopf;": "\u210D", |
||
8236 | "horbar;": "\u2015", |
||
8237 | "HorizontalLine;": "\u2500", |
||
8238 | "hscr;": "\uD835\uDCBD", |
||
8239 | "Hscr;": "\u210B", |
||
8240 | "hslash;": "\u210F", |
||
8241 | "Hstrok;": "\u0126", |
||
8242 | "hstrok;": "\u0127", |
||
8243 | "HumpDownHump;": "\u224E", |
||
8244 | "HumpEqual;": "\u224F", |
||
8245 | "hybull;": "\u2043", |
||
8246 | "hyphen;": "\u2010", |
||
8247 | "Iacute;": "\u00CD", |
||
8248 | "Iacute": "\u00CD", |
||
8249 | "iacute;": "\u00ED", |
||
8250 | "iacute": "\u00ED", |
||
8251 | "ic;": "\u2063", |
||
8252 | "Icirc;": "\u00CE", |
||
8253 | "Icirc": "\u00CE", |
||
8254 | "icirc;": "\u00EE", |
||
8255 | "icirc": "\u00EE", |
||
8256 | "Icy;": "\u0418", |
||
8257 | "icy;": "\u0438", |
||
8258 | "Idot;": "\u0130", |
||
8259 | "IEcy;": "\u0415", |
||
8260 | "iecy;": "\u0435", |
||
8261 | "iexcl;": "\u00A1", |
||
8262 | "iexcl": "\u00A1", |
||
8263 | "iff;": "\u21D4", |
||
8264 | "ifr;": "\uD835\uDD26", |
||
8265 | "Ifr;": "\u2111", |
||
8266 | "Igrave;": "\u00CC", |
||
8267 | "Igrave": "\u00CC", |
||
8268 | "igrave;": "\u00EC", |
||
8269 | "igrave": "\u00EC", |
||
8270 | "ii;": "\u2148", |
||
8271 | "iiiint;": "\u2A0C", |
||
8272 | "iiint;": "\u222D", |
||
8273 | "iinfin;": "\u29DC", |
||
8274 | "iiota;": "\u2129", |
||
8275 | "IJlig;": "\u0132", |
||
8276 | "ijlig;": "\u0133", |
||
8277 | "Imacr;": "\u012A", |
||
8278 | "imacr;": "\u012B", |
||
8279 | "image;": "\u2111", |
||
8280 | "ImaginaryI;": "\u2148", |
||
8281 | "imagline;": "\u2110", |
||
8282 | "imagpart;": "\u2111", |
||
8283 | "imath;": "\u0131", |
||
8284 | "Im;": "\u2111", |
||
8285 | "imof;": "\u22B7", |
||
8286 | "imped;": "\u01B5", |
||
8287 | "Implies;": "\u21D2", |
||
8288 | "incare;": "\u2105", |
||
8289 | "in;": "\u2208", |
||
8290 | "infin;": "\u221E", |
||
8291 | "infintie;": "\u29DD", |
||
8292 | "inodot;": "\u0131", |
||
8293 | "intcal;": "\u22BA", |
||
8294 | "int;": "\u222B", |
||
8295 | "Int;": "\u222C", |
||
8296 | "integers;": "\u2124", |
||
8297 | "Integral;": "\u222B", |
||
8298 | "intercal;": "\u22BA", |
||
8299 | "Intersection;": "\u22C2", |
||
8300 | "intlarhk;": "\u2A17", |
||
8301 | "intprod;": "\u2A3C", |
||
8302 | "InvisibleComma;": "\u2063", |
||
8303 | "InvisibleTimes;": "\u2062", |
||
8304 | "IOcy;": "\u0401", |
||
8305 | "iocy;": "\u0451", |
||
8306 | "Iogon;": "\u012E", |
||
8307 | "iogon;": "\u012F", |
||
8308 | "Iopf;": "\uD835\uDD40", |
||
8309 | "iopf;": "\uD835\uDD5A", |
||
8310 | "Iota;": "\u0399", |
||
8311 | "iota;": "\u03B9", |
||
8312 | "iprod;": "\u2A3C", |
||
8313 | "iquest;": "\u00BF", |
||
8314 | "iquest": "\u00BF", |
||
8315 | "iscr;": "\uD835\uDCBE", |
||
8316 | "Iscr;": "\u2110", |
||
8317 | "isin;": "\u2208", |
||
8318 | "isindot;": "\u22F5", |
||
8319 | "isinE;": "\u22F9", |
||
8320 | "isins;": "\u22F4", |
||
8321 | "isinsv;": "\u22F3", |
||
8322 | "isinv;": "\u2208", |
||
8323 | "it;": "\u2062", |
||
8324 | "Itilde;": "\u0128", |
||
8325 | "itilde;": "\u0129", |
||
8326 | "Iukcy;": "\u0406", |
||
8327 | "iukcy;": "\u0456", |
||
8328 | "Iuml;": "\u00CF", |
||
8329 | "Iuml": "\u00CF", |
||
8330 | "iuml;": "\u00EF", |
||
8331 | "iuml": "\u00EF", |
||
8332 | "Jcirc;": "\u0134", |
||
8333 | "jcirc;": "\u0135", |
||
8334 | "Jcy;": "\u0419", |
||
8335 | "jcy;": "\u0439", |
||
8336 | "Jfr;": "\uD835\uDD0D", |
||
8337 | "jfr;": "\uD835\uDD27", |
||
8338 | "jmath;": "\u0237", |
||
8339 | "Jopf;": "\uD835\uDD41", |
||
8340 | "jopf;": "\uD835\uDD5B", |
||
8341 | "Jscr;": "\uD835\uDCA5", |
||
8342 | "jscr;": "\uD835\uDCBF", |
||
8343 | "Jsercy;": "\u0408", |
||
8344 | "jsercy;": "\u0458", |
||
8345 | "Jukcy;": "\u0404", |
||
8346 | "jukcy;": "\u0454", |
||
8347 | "Kappa;": "\u039A", |
||
8348 | "kappa;": "\u03BA", |
||
8349 | "kappav;": "\u03F0", |
||
8350 | "Kcedil;": "\u0136", |
||
8351 | "kcedil;": "\u0137", |
||
8352 | "Kcy;": "\u041A", |
||
8353 | "kcy;": "\u043A", |
||
8354 | "Kfr;": "\uD835\uDD0E", |
||
8355 | "kfr;": "\uD835\uDD28", |
||
8356 | "kgreen;": "\u0138", |
||
8357 | "KHcy;": "\u0425", |
||
8358 | "khcy;": "\u0445", |
||
8359 | "KJcy;": "\u040C", |
||
8360 | "kjcy;": "\u045C", |
||
8361 | "Kopf;": "\uD835\uDD42", |
||
8362 | "kopf;": "\uD835\uDD5C", |
||
8363 | "Kscr;": "\uD835\uDCA6", |
||
8364 | "kscr;": "\uD835\uDCC0", |
||
8365 | "lAarr;": "\u21DA", |
||
8366 | "Lacute;": "\u0139", |
||
8367 | "lacute;": "\u013A", |
||
8368 | "laemptyv;": "\u29B4", |
||
8369 | "lagran;": "\u2112", |
||
8370 | "Lambda;": "\u039B", |
||
8371 | "lambda;": "\u03BB", |
||
8372 | "lang;": "\u27E8", |
||
8373 | "Lang;": "\u27EA", |
||
8374 | "langd;": "\u2991", |
||
8375 | "langle;": "\u27E8", |
||
8376 | "lap;": "\u2A85", |
||
8377 | "Laplacetrf;": "\u2112", |
||
8378 | "laquo;": "\u00AB", |
||
8379 | "laquo": "\u00AB", |
||
8380 | "larrb;": "\u21E4", |
||
8381 | "larrbfs;": "\u291F", |
||
8382 | "larr;": "\u2190", |
||
8383 | "Larr;": "\u219E", |
||
8384 | "lArr;": "\u21D0", |
||
8385 | "larrfs;": "\u291D", |
||
8386 | "larrhk;": "\u21A9", |
||
8387 | "larrlp;": "\u21AB", |
||
8388 | "larrpl;": "\u2939", |
||
8389 | "larrsim;": "\u2973", |
||
8390 | "larrtl;": "\u21A2", |
||
8391 | "latail;": "\u2919", |
||
8392 | "lAtail;": "\u291B", |
||
8393 | "lat;": "\u2AAB", |
||
8394 | "late;": "\u2AAD", |
||
8395 | "lates;": "\u2AAD\uFE00", |
||
8396 | "lbarr;": "\u290C", |
||
8397 | "lBarr;": "\u290E", |
||
8398 | "lbbrk;": "\u2772", |
||
8399 | "lbrace;": "\u007B", |
||
8400 | "lbrack;": "\u005B", |
||
8401 | "lbrke;": "\u298B", |
||
8402 | "lbrksld;": "\u298F", |
||
8403 | "lbrkslu;": "\u298D", |
||
8404 | "Lcaron;": "\u013D", |
||
8405 | "lcaron;": "\u013E", |
||
8406 | "Lcedil;": "\u013B", |
||
8407 | "lcedil;": "\u013C", |
||
8408 | "lceil;": "\u2308", |
||
8409 | "lcub;": "\u007B", |
||
8410 | "Lcy;": "\u041B", |
||
8411 | "lcy;": "\u043B", |
||
8412 | "ldca;": "\u2936", |
||
8413 | "ldquo;": "\u201C", |
||
8414 | "ldquor;": "\u201E", |
||
8415 | "ldrdhar;": "\u2967", |
||
8416 | "ldrushar;": "\u294B", |
||
8417 | "ldsh;": "\u21B2", |
||
8418 | "le;": "\u2264", |
||
8419 | "lE;": "\u2266", |
||
8420 | "LeftAngleBracket;": "\u27E8", |
||
8421 | "LeftArrowBar;": "\u21E4", |
||
8422 | "leftarrow;": "\u2190", |
||
8423 | "LeftArrow;": "\u2190", |
||
8424 | "Leftarrow;": "\u21D0", |
||
8425 | "LeftArrowRightArrow;": "\u21C6", |
||
8426 | "leftarrowtail;": "\u21A2", |
||
8427 | "LeftCeiling;": "\u2308", |
||
8428 | "LeftDoubleBracket;": "\u27E6", |
||
8429 | "LeftDownTeeVector;": "\u2961", |
||
8430 | "LeftDownVectorBar;": "\u2959", |
||
8431 | "LeftDownVector;": "\u21C3", |
||
8432 | "LeftFloor;": "\u230A", |
||
8433 | "leftharpoondown;": "\u21BD", |
||
8434 | "leftharpoonup;": "\u21BC", |
||
8435 | "leftleftarrows;": "\u21C7", |
||
8436 | "leftrightarrow;": "\u2194", |
||
8437 | "LeftRightArrow;": "\u2194", |
||
8438 | "Leftrightarrow;": "\u21D4", |
||
8439 | "leftrightarrows;": "\u21C6", |
||
8440 | "leftrightharpoons;": "\u21CB", |
||
8441 | "leftrightsquigarrow;": "\u21AD", |
||
8442 | "LeftRightVector;": "\u294E", |
||
8443 | "LeftTeeArrow;": "\u21A4", |
||
8444 | "LeftTee;": "\u22A3", |
||
8445 | "LeftTeeVector;": "\u295A", |
||
8446 | "leftthreetimes;": "\u22CB", |
||
8447 | "LeftTriangleBar;": "\u29CF", |
||
8448 | "LeftTriangle;": "\u22B2", |
||
8449 | "LeftTriangleEqual;": "\u22B4", |
||
8450 | "LeftUpDownVector;": "\u2951", |
||
8451 | "LeftUpTeeVector;": "\u2960", |
||
8452 | "LeftUpVectorBar;": "\u2958", |
||
8453 | "LeftUpVector;": "\u21BF", |
||
8454 | "LeftVectorBar;": "\u2952", |
||
8455 | "LeftVector;": "\u21BC", |
||
8456 | "lEg;": "\u2A8B", |
||
8457 | "leg;": "\u22DA", |
||
8458 | "leq;": "\u2264", |
||
8459 | "leqq;": "\u2266", |
||
8460 | "leqslant;": "\u2A7D", |
||
8461 | "lescc;": "\u2AA8", |
||
8462 | "les;": "\u2A7D", |
||
8463 | "lesdot;": "\u2A7F", |
||
8464 | "lesdoto;": "\u2A81", |
||
8465 | "lesdotor;": "\u2A83", |
||
8466 | "lesg;": "\u22DA\uFE00", |
||
8467 | "lesges;": "\u2A93", |
||
8468 | "lessapprox;": "\u2A85", |
||
8469 | "lessdot;": "\u22D6", |
||
8470 | "lesseqgtr;": "\u22DA", |
||
8471 | "lesseqqgtr;": "\u2A8B", |
||
8472 | "LessEqualGreater;": "\u22DA", |
||
8473 | "LessFullEqual;": "\u2266", |
||
8474 | "LessGreater;": "\u2276", |
||
8475 | "lessgtr;": "\u2276", |
||
8476 | "LessLess;": "\u2AA1", |
||
8477 | "lesssim;": "\u2272", |
||
8478 | "LessSlantEqual;": "\u2A7D", |
||
8479 | "LessTilde;": "\u2272", |
||
8480 | "lfisht;": "\u297C", |
||
8481 | "lfloor;": "\u230A", |
||
8482 | "Lfr;": "\uD835\uDD0F", |
||
8483 | "lfr;": "\uD835\uDD29", |
||
8484 | "lg;": "\u2276", |
||
8485 | "lgE;": "\u2A91", |
||
8486 | "lHar;": "\u2962", |
||
8487 | "lhard;": "\u21BD", |
||
8488 | "lharu;": "\u21BC", |
||
8489 | "lharul;": "\u296A", |
||
8490 | "lhblk;": "\u2584", |
||
8491 | "LJcy;": "\u0409", |
||
8492 | "ljcy;": "\u0459", |
||
8493 | "llarr;": "\u21C7", |
||
8494 | "ll;": "\u226A", |
||
8495 | "Ll;": "\u22D8", |
||
8496 | "llcorner;": "\u231E", |
||
8497 | "Lleftarrow;": "\u21DA", |
||
8498 | "llhard;": "\u296B", |
||
8499 | "lltri;": "\u25FA", |
||
8500 | "Lmidot;": "\u013F", |
||
8501 | "lmidot;": "\u0140", |
||
8502 | "lmoustache;": "\u23B0", |
||
8503 | "lmoust;": "\u23B0", |
||
8504 | "lnap;": "\u2A89", |
||
8505 | "lnapprox;": "\u2A89", |
||
8506 | "lne;": "\u2A87", |
||
8507 | "lnE;": "\u2268", |
||
8508 | "lneq;": "\u2A87", |
||
8509 | "lneqq;": "\u2268", |
||
8510 | "lnsim;": "\u22E6", |
||
8511 | "loang;": "\u27EC", |
||
8512 | "loarr;": "\u21FD", |
||
8513 | "lobrk;": "\u27E6", |
||
8514 | "longleftarrow;": "\u27F5", |
||
8515 | "LongLeftArrow;": "\u27F5", |
||
8516 | "Longleftarrow;": "\u27F8", |
||
8517 | "longleftrightarrow;": "\u27F7", |
||
8518 | "LongLeftRightArrow;": "\u27F7", |
||
8519 | "Longleftrightarrow;": "\u27FA", |
||
8520 | "longmapsto;": "\u27FC", |
||
8521 | "longrightarrow;": "\u27F6", |
||
8522 | "LongRightArrow;": "\u27F6", |
||
8523 | "Longrightarrow;": "\u27F9", |
||
8524 | "looparrowleft;": "\u21AB", |
||
8525 | "looparrowright;": "\u21AC", |
||
8526 | "lopar;": "\u2985", |
||
8527 | "Lopf;": "\uD835\uDD43", |
||
8528 | "lopf;": "\uD835\uDD5D", |
||
8529 | "loplus;": "\u2A2D", |
||
8530 | "lotimes;": "\u2A34", |
||
8531 | "lowast;": "\u2217", |
||
8532 | "lowbar;": "\u005F", |
||
8533 | "LowerLeftArrow;": "\u2199", |
||
8534 | "LowerRightArrow;": "\u2198", |
||
8535 | "loz;": "\u25CA", |
||
8536 | "lozenge;": "\u25CA", |
||
8537 | "lozf;": "\u29EB", |
||
8538 | "lpar;": "\u0028", |
||
8539 | "lparlt;": "\u2993", |
||
8540 | "lrarr;": "\u21C6", |
||
8541 | "lrcorner;": "\u231F", |
||
8542 | "lrhar;": "\u21CB", |
||
8543 | "lrhard;": "\u296D", |
||
8544 | "lrm;": "\u200E", |
||
8545 | "lrtri;": "\u22BF", |
||
8546 | "lsaquo;": "\u2039", |
||
8547 | "lscr;": "\uD835\uDCC1", |
||
8548 | "Lscr;": "\u2112", |
||
8549 | "lsh;": "\u21B0", |
||
8550 | "Lsh;": "\u21B0", |
||
8551 | "lsim;": "\u2272", |
||
8552 | "lsime;": "\u2A8D", |
||
8553 | "lsimg;": "\u2A8F", |
||
8554 | "lsqb;": "\u005B", |
||
8555 | "lsquo;": "\u2018", |
||
8556 | "lsquor;": "\u201A", |
||
8557 | "Lstrok;": "\u0141", |
||
8558 | "lstrok;": "\u0142", |
||
8559 | "ltcc;": "\u2AA6", |
||
8560 | "ltcir;": "\u2A79", |
||
8561 | "lt;": "\u003C", |
||
8562 | "lt": "\u003C", |
||
8563 | "LT;": "\u003C", |
||
8564 | "LT": "\u003C", |
||
8565 | "Lt;": "\u226A", |
||
8566 | "ltdot;": "\u22D6", |
||
8567 | "lthree;": "\u22CB", |
||
8568 | "ltimes;": "\u22C9", |
||
8569 | "ltlarr;": "\u2976", |
||
8570 | "ltquest;": "\u2A7B", |
||
8571 | "ltri;": "\u25C3", |
||
8572 | "ltrie;": "\u22B4", |
||
8573 | "ltrif;": "\u25C2", |
||
8574 | "ltrPar;": "\u2996", |
||
8575 | "lurdshar;": "\u294A", |
||
8576 | "luruhar;": "\u2966", |
||
8577 | "lvertneqq;": "\u2268\uFE00", |
||
8578 | "lvnE;": "\u2268\uFE00", |
||
8579 | "macr;": "\u00AF", |
||
8580 | "macr": "\u00AF", |
||
8581 | "male;": "\u2642", |
||
8582 | "malt;": "\u2720", |
||
8583 | "maltese;": "\u2720", |
||
8584 | "Map;": "\u2905", |
||
8585 | "map;": "\u21A6", |
||
8586 | "mapsto;": "\u21A6", |
||
8587 | "mapstodown;": "\u21A7", |
||
8588 | "mapstoleft;": "\u21A4", |
||
8589 | "mapstoup;": "\u21A5", |
||
8590 | "marker;": "\u25AE", |
||
8591 | "mcomma;": "\u2A29", |
||
8592 | "Mcy;": "\u041C", |
||
8593 | "mcy;": "\u043C", |
||
8594 | "mdash;": "\u2014", |
||
8595 | "mDDot;": "\u223A", |
||
8596 | "measuredangle;": "\u2221", |
||
8597 | "MediumSpace;": "\u205F", |
||
8598 | "Mellintrf;": "\u2133", |
||
8599 | "Mfr;": "\uD835\uDD10", |
||
8600 | "mfr;": "\uD835\uDD2A", |
||
8601 | "mho;": "\u2127", |
||
8602 | "micro;": "\u00B5", |
||
8603 | "micro": "\u00B5", |
||
8604 | "midast;": "\u002A", |
||
8605 | "midcir;": "\u2AF0", |
||
8606 | "mid;": "\u2223", |
||
8607 | "middot;": "\u00B7", |
||
8608 | "middot": "\u00B7", |
||
8609 | "minusb;": "\u229F", |
||
8610 | "minus;": "\u2212", |
||
8611 | "minusd;": "\u2238", |
||
8612 | "minusdu;": "\u2A2A", |
||
8613 | "MinusPlus;": "\u2213", |
||
8614 | "mlcp;": "\u2ADB", |
||
8615 | "mldr;": "\u2026", |
||
8616 | "mnplus;": "\u2213", |
||
8617 | "models;": "\u22A7", |
||
8618 | "Mopf;": "\uD835\uDD44", |
||
8619 | "mopf;": "\uD835\uDD5E", |
||
8620 | "mp;": "\u2213", |
||
8621 | "mscr;": "\uD835\uDCC2", |
||
8622 | "Mscr;": "\u2133", |
||
8623 | "mstpos;": "\u223E", |
||
8624 | "Mu;": "\u039C", |
||
8625 | "mu;": "\u03BC", |
||
8626 | "multimap;": "\u22B8", |
||
8627 | "mumap;": "\u22B8", |
||
8628 | "nabla;": "\u2207", |
||
8629 | "Nacute;": "\u0143", |
||
8630 | "nacute;": "\u0144", |
||
8631 | "nang;": "\u2220\u20D2", |
||
8632 | "nap;": "\u2249", |
||
8633 | "napE;": "\u2A70\u0338", |
||
8634 | "napid;": "\u224B\u0338", |
||
8635 | "napos;": "\u0149", |
||
8636 | "napprox;": "\u2249", |
||
8637 | "natural;": "\u266E", |
||
8638 | "naturals;": "\u2115", |
||
8639 | "natur;": "\u266E", |
||
8640 | "nbsp;": "\u00A0", |
||
8641 | "nbsp": "\u00A0", |
||
8642 | "nbump;": "\u224E\u0338", |
||
8643 | "nbumpe;": "\u224F\u0338", |
||
8644 | "ncap;": "\u2A43", |
||
8645 | "Ncaron;": "\u0147", |
||
8646 | "ncaron;": "\u0148", |
||
8647 | "Ncedil;": "\u0145", |
||
8648 | "ncedil;": "\u0146", |
||
8649 | "ncong;": "\u2247", |
||
8650 | "ncongdot;": "\u2A6D\u0338", |
||
8651 | "ncup;": "\u2A42", |
||
8652 | "Ncy;": "\u041D", |
||
8653 | "ncy;": "\u043D", |
||
8654 | "ndash;": "\u2013", |
||
8655 | "nearhk;": "\u2924", |
||
8656 | "nearr;": "\u2197", |
||
8657 | "neArr;": "\u21D7", |
||
8658 | "nearrow;": "\u2197", |
||
8659 | "ne;": "\u2260", |
||
8660 | "nedot;": "\u2250\u0338", |
||
8661 | "NegativeMediumSpace;": "\u200B", |
||
8662 | "NegativeThickSpace;": "\u200B", |
||
8663 | "NegativeThinSpace;": "\u200B", |
||
8664 | "NegativeVeryThinSpace;": "\u200B", |
||
8665 | "nequiv;": "\u2262", |
||
8666 | "nesear;": "\u2928", |
||
8667 | "nesim;": "\u2242\u0338", |
||
8668 | "NestedGreaterGreater;": "\u226B", |
||
8669 | "NestedLessLess;": "\u226A", |
||
8670 | "NewLine;": "\u000A", |
||
8671 | "nexist;": "\u2204", |
||
8672 | "nexists;": "\u2204", |
||
8673 | "Nfr;": "\uD835\uDD11", |
||
8674 | "nfr;": "\uD835\uDD2B", |
||
8675 | "ngE;": "\u2267\u0338", |
||
8676 | "nge;": "\u2271", |
||
8677 | "ngeq;": "\u2271", |
||
8678 | "ngeqq;": "\u2267\u0338", |
||
8679 | "ngeqslant;": "\u2A7E\u0338", |
||
8680 | "nges;": "\u2A7E\u0338", |
||
8681 | "nGg;": "\u22D9\u0338", |
||
8682 | "ngsim;": "\u2275", |
||
8683 | "nGt;": "\u226B\u20D2", |
||
8684 | "ngt;": "\u226F", |
||
8685 | "ngtr;": "\u226F", |
||
8686 | "nGtv;": "\u226B\u0338", |
||
8687 | "nharr;": "\u21AE", |
||
8688 | "nhArr;": "\u21CE", |
||
8689 | "nhpar;": "\u2AF2", |
||
8690 | "ni;": "\u220B", |
||
8691 | "nis;": "\u22FC", |
||
8692 | "nisd;": "\u22FA", |
||
8693 | "niv;": "\u220B", |
||
8694 | "NJcy;": "\u040A", |
||
8695 | "njcy;": "\u045A", |
||
8696 | "nlarr;": "\u219A", |
||
8697 | "nlArr;": "\u21CD", |
||
8698 | "nldr;": "\u2025", |
||
8699 | "nlE;": "\u2266\u0338", |
||
8700 | "nle;": "\u2270", |
||
8701 | "nleftarrow;": "\u219A", |
||
8702 | "nLeftarrow;": "\u21CD", |
||
8703 | "nleftrightarrow;": "\u21AE", |
||
8704 | "nLeftrightarrow;": "\u21CE", |
||
8705 | "nleq;": "\u2270", |
||
8706 | "nleqq;": "\u2266\u0338", |
||
8707 | "nleqslant;": "\u2A7D\u0338", |
||
8708 | "nles;": "\u2A7D\u0338", |
||
8709 | "nless;": "\u226E", |
||
8710 | "nLl;": "\u22D8\u0338", |
||
8711 | "nlsim;": "\u2274", |
||
8712 | "nLt;": "\u226A\u20D2", |
||
8713 | "nlt;": "\u226E", |
||
8714 | "nltri;": "\u22EA", |
||
8715 | "nltrie;": "\u22EC", |
||
8716 | "nLtv;": "\u226A\u0338", |
||
8717 | "nmid;": "\u2224", |
||
8718 | "NoBreak;": "\u2060", |
||
8719 | "NonBreakingSpace;": "\u00A0", |
||
8720 | "nopf;": "\uD835\uDD5F", |
||
8721 | "Nopf;": "\u2115", |
||
8722 | "Not;": "\u2AEC", |
||
8723 | "not;": "\u00AC", |
||
8724 | "not": "\u00AC", |
||
8725 | "NotCongruent;": "\u2262", |
||
8726 | "NotCupCap;": "\u226D", |
||
8727 | "NotDoubleVerticalBar;": "\u2226", |
||
8728 | "NotElement;": "\u2209", |
||
8729 | "NotEqual;": "\u2260", |
||
8730 | "NotEqualTilde;": "\u2242\u0338", |
||
8731 | "NotExists;": "\u2204", |
||
8732 | "NotGreater;": "\u226F", |
||
8733 | "NotGreaterEqual;": "\u2271", |
||
8734 | "NotGreaterFullEqual;": "\u2267\u0338", |
||
8735 | "NotGreaterGreater;": "\u226B\u0338", |
||
8736 | "NotGreaterLess;": "\u2279", |
||
8737 | "NotGreaterSlantEqual;": "\u2A7E\u0338", |
||
8738 | "NotGreaterTilde;": "\u2275", |
||
8739 | "NotHumpDownHump;": "\u224E\u0338", |
||
8740 | "NotHumpEqual;": "\u224F\u0338", |
||
8741 | "notin;": "\u2209", |
||
8742 | "notindot;": "\u22F5\u0338", |
||
8743 | "notinE;": "\u22F9\u0338", |
||
8744 | "notinva;": "\u2209", |
||
8745 | "notinvb;": "\u22F7", |
||
8746 | "notinvc;": "\u22F6", |
||
8747 | "NotLeftTriangleBar;": "\u29CF\u0338", |
||
8748 | "NotLeftTriangle;": "\u22EA", |
||
8749 | "NotLeftTriangleEqual;": "\u22EC", |
||
8750 | "NotLess;": "\u226E", |
||
8751 | "NotLessEqual;": "\u2270", |
||
8752 | "NotLessGreater;": "\u2278", |
||
8753 | "NotLessLess;": "\u226A\u0338", |
||
8754 | "NotLessSlantEqual;": "\u2A7D\u0338", |
||
8755 | "NotLessTilde;": "\u2274", |
||
8756 | "NotNestedGreaterGreater;": "\u2AA2\u0338", |
||
8757 | "NotNestedLessLess;": "\u2AA1\u0338", |
||
8758 | "notni;": "\u220C", |
||
8759 | "notniva;": "\u220C", |
||
8760 | "notnivb;": "\u22FE", |
||
8761 | "notnivc;": "\u22FD", |
||
8762 | "NotPrecedes;": "\u2280", |
||
8763 | "NotPrecedesEqual;": "\u2AAF\u0338", |
||
8764 | "NotPrecedesSlantEqual;": "\u22E0", |
||
8765 | "NotReverseElement;": "\u220C", |
||
8766 | "NotRightTriangleBar;": "\u29D0\u0338", |
||
8767 | "NotRightTriangle;": "\u22EB", |
||
8768 | "NotRightTriangleEqual;": "\u22ED", |
||
8769 | "NotSquareSubset;": "\u228F\u0338", |
||
8770 | "NotSquareSubsetEqual;": "\u22E2", |
||
8771 | "NotSquareSuperset;": "\u2290\u0338", |
||
8772 | "NotSquareSupersetEqual;": "\u22E3", |
||
8773 | "NotSubset;": "\u2282\u20D2", |
||
8774 | "NotSubsetEqual;": "\u2288", |
||
8775 | "NotSucceeds;": "\u2281", |
||
8776 | "NotSucceedsEqual;": "\u2AB0\u0338", |
||
8777 | "NotSucceedsSlantEqual;": "\u22E1", |
||
8778 | "NotSucceedsTilde;": "\u227F\u0338", |
||
8779 | "NotSuperset;": "\u2283\u20D2", |
||
8780 | "NotSupersetEqual;": "\u2289", |
||
8781 | "NotTilde;": "\u2241", |
||
8782 | "NotTildeEqual;": "\u2244", |
||
8783 | "NotTildeFullEqual;": "\u2247", |
||
8784 | "NotTildeTilde;": "\u2249", |
||
8785 | "NotVerticalBar;": "\u2224", |
||
8786 | "nparallel;": "\u2226", |
||
8787 | "npar;": "\u2226", |
||
8788 | "nparsl;": "\u2AFD\u20E5", |
||
8789 | "npart;": "\u2202\u0338", |
||
8790 | "npolint;": "\u2A14", |
||
8791 | "npr;": "\u2280", |
||
8792 | "nprcue;": "\u22E0", |
||
8793 | "nprec;": "\u2280", |
||
8794 | "npreceq;": "\u2AAF\u0338", |
||
8795 | "npre;": "\u2AAF\u0338", |
||
8796 | "nrarrc;": "\u2933\u0338", |
||
8797 | "nrarr;": "\u219B", |
||
8798 | "nrArr;": "\u21CF", |
||
8799 | "nrarrw;": "\u219D\u0338", |
||
8800 | "nrightarrow;": "\u219B", |
||
8801 | "nRightarrow;": "\u21CF", |
||
8802 | "nrtri;": "\u22EB", |
||
8803 | "nrtrie;": "\u22ED", |
||
8804 | "nsc;": "\u2281", |
||
8805 | "nsccue;": "\u22E1", |
||
8806 | "nsce;": "\u2AB0\u0338", |
||
8807 | "Nscr;": "\uD835\uDCA9", |
||
8808 | "nscr;": "\uD835\uDCC3", |
||
8809 | "nshortmid;": "\u2224", |
||
8810 | "nshortparallel;": "\u2226", |
||
8811 | "nsim;": "\u2241", |
||
8812 | "nsime;": "\u2244", |
||
8813 | "nsimeq;": "\u2244", |
||
8814 | "nsmid;": "\u2224", |
||
8815 | "nspar;": "\u2226", |
||
8816 | "nsqsube;": "\u22E2", |
||
8817 | "nsqsupe;": "\u22E3", |
||
8818 | "nsub;": "\u2284", |
||
8819 | "nsubE;": "\u2AC5\u0338", |
||
8820 | "nsube;": "\u2288", |
||
8821 | "nsubset;": "\u2282\u20D2", |
||
8822 | "nsubseteq;": "\u2288", |
||
8823 | "nsubseteqq;": "\u2AC5\u0338", |
||
8824 | "nsucc;": "\u2281", |
||
8825 | "nsucceq;": "\u2AB0\u0338", |
||
8826 | "nsup;": "\u2285", |
||
8827 | "nsupE;": "\u2AC6\u0338", |
||
8828 | "nsupe;": "\u2289", |
||
8829 | "nsupset;": "\u2283\u20D2", |
||
8830 | "nsupseteq;": "\u2289", |
||
8831 | "nsupseteqq;": "\u2AC6\u0338", |
||
8832 | "ntgl;": "\u2279", |
||
8833 | "Ntilde;": "\u00D1", |
||
8834 | "Ntilde": "\u00D1", |
||
8835 | "ntilde;": "\u00F1", |
||
8836 | "ntilde": "\u00F1", |
||
8837 | "ntlg;": "\u2278", |
||
8838 | "ntriangleleft;": "\u22EA", |
||
8839 | "ntrianglelefteq;": "\u22EC", |
||
8840 | "ntriangleright;": "\u22EB", |
||
8841 | "ntrianglerighteq;": "\u22ED", |
||
8842 | "Nu;": "\u039D", |
||
8843 | "nu;": "\u03BD", |
||
8844 | "num;": "\u0023", |
||
8845 | "numero;": "\u2116", |
||
8846 | "numsp;": "\u2007", |
||
8847 | "nvap;": "\u224D\u20D2", |
||
8848 | "nvdash;": "\u22AC", |
||
8849 | "nvDash;": "\u22AD", |
||
8850 | "nVdash;": "\u22AE", |
||
8851 | "nVDash;": "\u22AF", |
||
8852 | "nvge;": "\u2265\u20D2", |
||
8853 | "nvgt;": "\u003E\u20D2", |
||
8854 | "nvHarr;": "\u2904", |
||
8855 | "nvinfin;": "\u29DE", |
||
8856 | "nvlArr;": "\u2902", |
||
8857 | "nvle;": "\u2264\u20D2", |
||
8858 | "nvlt;": "\u003C\u20D2", |
||
8859 | "nvltrie;": "\u22B4\u20D2", |
||
8860 | "nvrArr;": "\u2903", |
||
8861 | "nvrtrie;": "\u22B5\u20D2", |
||
8862 | "nvsim;": "\u223C\u20D2", |
||
8863 | "nwarhk;": "\u2923", |
||
8864 | "nwarr;": "\u2196", |
||
8865 | "nwArr;": "\u21D6", |
||
8866 | "nwarrow;": "\u2196", |
||
8867 | "nwnear;": "\u2927", |
||
8868 | "Oacute;": "\u00D3", |
||
8869 | "Oacute": "\u00D3", |
||
8870 | "oacute;": "\u00F3", |
||
8871 | "oacute": "\u00F3", |
||
8872 | "oast;": "\u229B", |
||
8873 | "Ocirc;": "\u00D4", |
||
8874 | "Ocirc": "\u00D4", |
||
8875 | "ocirc;": "\u00F4", |
||
8876 | "ocirc": "\u00F4", |
||
8877 | "ocir;": "\u229A", |
||
8878 | "Ocy;": "\u041E", |
||
8879 | "ocy;": "\u043E", |
||
8880 | "odash;": "\u229D", |
||
8881 | "Odblac;": "\u0150", |
||
8882 | "odblac;": "\u0151", |
||
8883 | "odiv;": "\u2A38", |
||
8884 | "odot;": "\u2299", |
||
8885 | "odsold;": "\u29BC", |
||
8886 | "OElig;": "\u0152", |
||
8887 | "oelig;": "\u0153", |
||
8888 | "ofcir;": "\u29BF", |
||
8889 | "Ofr;": "\uD835\uDD12", |
||
8890 | "ofr;": "\uD835\uDD2C", |
||
8891 | "ogon;": "\u02DB", |
||
8892 | "Ograve;": "\u00D2", |
||
8893 | "Ograve": "\u00D2", |
||
8894 | "ograve;": "\u00F2", |
||
8895 | "ograve": "\u00F2", |
||
8896 | "ogt;": "\u29C1", |
||
8897 | "ohbar;": "\u29B5", |
||
8898 | "ohm;": "\u03A9", |
||
8899 | "oint;": "\u222E", |
||
8900 | "olarr;": "\u21BA", |
||
8901 | "olcir;": "\u29BE", |
||
8902 | "olcross;": "\u29BB", |
||
8903 | "oline;": "\u203E", |
||
8904 | "olt;": "\u29C0", |
||
8905 | "Omacr;": "\u014C", |
||
8906 | "omacr;": "\u014D", |
||
8907 | "Omega;": "\u03A9", |
||
8908 | "omega;": "\u03C9", |
||
8909 | "Omicron;": "\u039F", |
||
8910 | "omicron;": "\u03BF", |
||
8911 | "omid;": "\u29B6", |
||
8912 | "ominus;": "\u2296", |
||
8913 | "Oopf;": "\uD835\uDD46", |
||
8914 | "oopf;": "\uD835\uDD60", |
||
8915 | "opar;": "\u29B7", |
||
8916 | "OpenCurlyDoubleQuote;": "\u201C", |
||
8917 | "OpenCurlyQuote;": "\u2018", |
||
8918 | "operp;": "\u29B9", |
||
8919 | "oplus;": "\u2295", |
||
8920 | "orarr;": "\u21BB", |
||
8921 | "Or;": "\u2A54", |
||
8922 | "or;": "\u2228", |
||
8923 | "ord;": "\u2A5D", |
||
8924 | "order;": "\u2134", |
||
8925 | "orderof;": "\u2134", |
||
8926 | "ordf;": "\u00AA", |
||
8927 | "ordf": "\u00AA", |
||
8928 | "ordm;": "\u00BA", |
||
8929 | "ordm": "\u00BA", |
||
8930 | "origof;": "\u22B6", |
||
8931 | "oror;": "\u2A56", |
||
8932 | "orslope;": "\u2A57", |
||
8933 | "orv;": "\u2A5B", |
||
8934 | "oS;": "\u24C8", |
||
8935 | "Oscr;": "\uD835\uDCAA", |
||
8936 | "oscr;": "\u2134", |
||
8937 | "Oslash;": "\u00D8", |
||
8938 | "Oslash": "\u00D8", |
||
8939 | "oslash;": "\u00F8", |
||
8940 | "oslash": "\u00F8", |
||
8941 | "osol;": "\u2298", |
||
8942 | "Otilde;": "\u00D5", |
||
8943 | "Otilde": "\u00D5", |
||
8944 | "otilde;": "\u00F5", |
||
8945 | "otilde": "\u00F5", |
||
8946 | "otimesas;": "\u2A36", |
||
8947 | "Otimes;": "\u2A37", |
||
8948 | "otimes;": "\u2297", |
||
8949 | "Ouml;": "\u00D6", |
||
8950 | "Ouml": "\u00D6", |
||
8951 | "ouml;": "\u00F6", |
||
8952 | "ouml": "\u00F6", |
||
8953 | "ovbar;": "\u233D", |
||
8954 | "OverBar;": "\u203E", |
||
8955 | "OverBrace;": "\u23DE", |
||
8956 | "OverBracket;": "\u23B4", |
||
8957 | "OverParenthesis;": "\u23DC", |
||
8958 | "para;": "\u00B6", |
||
8959 | "para": "\u00B6", |
||
8960 | "parallel;": "\u2225", |
||
8961 | "par;": "\u2225", |
||
8962 | "parsim;": "\u2AF3", |
||
8963 | "parsl;": "\u2AFD", |
||
8964 | "part;": "\u2202", |
||
8965 | "PartialD;": "\u2202", |
||
8966 | "Pcy;": "\u041F", |
||
8967 | "pcy;": "\u043F", |
||
8968 | "percnt;": "\u0025", |
||
8969 | "period;": "\u002E", |
||
8970 | "permil;": "\u2030", |
||
8971 | "perp;": "\u22A5", |
||
8972 | "pertenk;": "\u2031", |
||
8973 | "Pfr;": "\uD835\uDD13", |
||
8974 | "pfr;": "\uD835\uDD2D", |
||
8975 | "Phi;": "\u03A6", |
||
8976 | "phi;": "\u03C6", |
||
8977 | "phiv;": "\u03D5", |
||
8978 | "phmmat;": "\u2133", |
||
8979 | "phone;": "\u260E", |
||
8980 | "Pi;": "\u03A0", |
||
8981 | "pi;": "\u03C0", |
||
8982 | "pitchfork;": "\u22D4", |
||
8983 | "piv;": "\u03D6", |
||
8984 | "planck;": "\u210F", |
||
8985 | "planckh;": "\u210E", |
||
8986 | "plankv;": "\u210F", |
||
8987 | "plusacir;": "\u2A23", |
||
8988 | "plusb;": "\u229E", |
||
8989 | "pluscir;": "\u2A22", |
||
8990 | "plus;": "\u002B", |
||
8991 | "plusdo;": "\u2214", |
||
8992 | "plusdu;": "\u2A25", |
||
8993 | "pluse;": "\u2A72", |
||
8994 | "PlusMinus;": "\u00B1", |
||
8995 | "plusmn;": "\u00B1", |
||
8996 | "plusmn": "\u00B1", |
||
8997 | "plussim;": "\u2A26", |
||
8998 | "plustwo;": "\u2A27", |
||
8999 | "pm;": "\u00B1", |
||
9000 | "Poincareplane;": "\u210C", |
||
9001 | "pointint;": "\u2A15", |
||
9002 | "popf;": "\uD835\uDD61", |
||
9003 | "Popf;": "\u2119", |
||
9004 | "pound;": "\u00A3", |
||
9005 | "pound": "\u00A3", |
||
9006 | "prap;": "\u2AB7", |
||
9007 | "Pr;": "\u2ABB", |
||
9008 | "pr;": "\u227A", |
||
9009 | "prcue;": "\u227C", |
||
9010 | "precapprox;": "\u2AB7", |
||
9011 | "prec;": "\u227A", |
||
9012 | "preccurlyeq;": "\u227C", |
||
9013 | "Precedes;": "\u227A", |
||
9014 | "PrecedesEqual;": "\u2AAF", |
||
9015 | "PrecedesSlantEqual;": "\u227C", |
||
9016 | "PrecedesTilde;": "\u227E", |
||
9017 | "preceq;": "\u2AAF", |
||
9018 | "precnapprox;": "\u2AB9", |
||
9019 | "precneqq;": "\u2AB5", |
||
9020 | "precnsim;": "\u22E8", |
||
9021 | "pre;": "\u2AAF", |
||
9022 | "prE;": "\u2AB3", |
||
9023 | "precsim;": "\u227E", |
||
9024 | "prime;": "\u2032", |
||
9025 | "Prime;": "\u2033", |
||
9026 | "primes;": "\u2119", |
||
9027 | "prnap;": "\u2AB9", |
||
9028 | "prnE;": "\u2AB5", |
||
9029 | "prnsim;": "\u22E8", |
||
9030 | "prod;": "\u220F", |
||
9031 | "Product;": "\u220F", |
||
9032 | "profalar;": "\u232E", |
||
9033 | "profline;": "\u2312", |
||
9034 | "profsurf;": "\u2313", |
||
9035 | "prop;": "\u221D", |
||
9036 | "Proportional;": "\u221D", |
||
9037 | "Proportion;": "\u2237", |
||
9038 | "propto;": "\u221D", |
||
9039 | "prsim;": "\u227E", |
||
9040 | "prurel;": "\u22B0", |
||
9041 | "Pscr;": "\uD835\uDCAB", |
||
9042 | "pscr;": "\uD835\uDCC5", |
||
9043 | "Psi;": "\u03A8", |
||
9044 | "psi;": "\u03C8", |
||
9045 | "puncsp;": "\u2008", |
||
9046 | "Qfr;": "\uD835\uDD14", |
||
9047 | "qfr;": "\uD835\uDD2E", |
||
9048 | "qint;": "\u2A0C", |
||
9049 | "qopf;": "\uD835\uDD62", |
||
9050 | "Qopf;": "\u211A", |
||
9051 | "qprime;": "\u2057", |
||
9052 | "Qscr;": "\uD835\uDCAC", |
||
9053 | "qscr;": "\uD835\uDCC6", |
||
9054 | "quaternions;": "\u210D", |
||
9055 | "quatint;": "\u2A16", |
||
9056 | "quest;": "\u003F", |
||
9057 | "questeq;": "\u225F", |
||
9058 | "quot;": "\u0022", |
||
9059 | "quot": "\u0022", |
||
9060 | "QUOT;": "\u0022", |
||
9061 | "QUOT": "\u0022", |
||
9062 | "rAarr;": "\u21DB", |
||
9063 | "race;": "\u223D\u0331", |
||
9064 | "Racute;": "\u0154", |
||
9065 | "racute;": "\u0155", |
||
9066 | "radic;": "\u221A", |
||
9067 | "raemptyv;": "\u29B3", |
||
9068 | "rang;": "\u27E9", |
||
9069 | "Rang;": "\u27EB", |
||
9070 | "rangd;": "\u2992", |
||
9071 | "range;": "\u29A5", |
||
9072 | "rangle;": "\u27E9", |
||
9073 | "raquo;": "\u00BB", |
||
9074 | "raquo": "\u00BB", |
||
9075 | "rarrap;": "\u2975", |
||
9076 | "rarrb;": "\u21E5", |
||
9077 | "rarrbfs;": "\u2920", |
||
9078 | "rarrc;": "\u2933", |
||
9079 | "rarr;": "\u2192", |
||
9080 | "Rarr;": "\u21A0", |
||
9081 | "rArr;": "\u21D2", |
||
9082 | "rarrfs;": "\u291E", |
||
9083 | "rarrhk;": "\u21AA", |
||
9084 | "rarrlp;": "\u21AC", |
||
9085 | "rarrpl;": "\u2945", |
||
9086 | "rarrsim;": "\u2974", |
||
9087 | "Rarrtl;": "\u2916", |
||
9088 | "rarrtl;": "\u21A3", |
||
9089 | "rarrw;": "\u219D", |
||
9090 | "ratail;": "\u291A", |
||
9091 | "rAtail;": "\u291C", |
||
9092 | "ratio;": "\u2236", |
||
9093 | "rationals;": "\u211A", |
||
9094 | "rbarr;": "\u290D", |
||
9095 | "rBarr;": "\u290F", |
||
9096 | "RBarr;": "\u2910", |
||
9097 | "rbbrk;": "\u2773", |
||
9098 | "rbrace;": "\u007D", |
||
9099 | "rbrack;": "\u005D", |
||
9100 | "rbrke;": "\u298C", |
||
9101 | "rbrksld;": "\u298E", |
||
9102 | "rbrkslu;": "\u2990", |
||
9103 | "Rcaron;": "\u0158", |
||
9104 | "rcaron;": "\u0159", |
||
9105 | "Rcedil;": "\u0156", |
||
9106 | "rcedil;": "\u0157", |
||
9107 | "rceil;": "\u2309", |
||
9108 | "rcub;": "\u007D", |
||
9109 | "Rcy;": "\u0420", |
||
9110 | "rcy;": "\u0440", |
||
9111 | "rdca;": "\u2937", |
||
9112 | "rdldhar;": "\u2969", |
||
9113 | "rdquo;": "\u201D", |
||
9114 | "rdquor;": "\u201D", |
||
9115 | "rdsh;": "\u21B3", |
||
9116 | "real;": "\u211C", |
||
9117 | "realine;": "\u211B", |
||
9118 | "realpart;": "\u211C", |
||
9119 | "reals;": "\u211D", |
||
9120 | "Re;": "\u211C", |
||
9121 | "rect;": "\u25AD", |
||
9122 | "reg;": "\u00AE", |
||
9123 | "reg": "\u00AE", |
||
9124 | "REG;": "\u00AE", |
||
9125 | "REG": "\u00AE", |
||
9126 | "ReverseElement;": "\u220B", |
||
9127 | "ReverseEquilibrium;": "\u21CB", |
||
9128 | "ReverseUpEquilibrium;": "\u296F", |
||
9129 | "rfisht;": "\u297D", |
||
9130 | "rfloor;": "\u230B", |
||
9131 | "rfr;": "\uD835\uDD2F", |
||
9132 | "Rfr;": "\u211C", |
||
9133 | "rHar;": "\u2964", |
||
9134 | "rhard;": "\u21C1", |
||
9135 | "rharu;": "\u21C0", |
||
9136 | "rharul;": "\u296C", |
||
9137 | "Rho;": "\u03A1", |
||
9138 | "rho;": "\u03C1", |
||
9139 | "rhov;": "\u03F1", |
||
9140 | "RightAngleBracket;": "\u27E9", |
||
9141 | "RightArrowBar;": "\u21E5", |
||
9142 | "rightarrow;": "\u2192", |
||
9143 | "RightArrow;": "\u2192", |
||
9144 | "Rightarrow;": "\u21D2", |
||
9145 | "RightArrowLeftArrow;": "\u21C4", |
||
9146 | "rightarrowtail;": "\u21A3", |
||
9147 | "RightCeiling;": "\u2309", |
||
9148 | "RightDoubleBracket;": "\u27E7", |
||
9149 | "RightDownTeeVector;": "\u295D", |
||
9150 | "RightDownVectorBar;": "\u2955", |
||
9151 | "RightDownVector;": "\u21C2", |
||
9152 | "RightFloor;": "\u230B", |
||
9153 | "rightharpoondown;": "\u21C1", |
||
9154 | "rightharpoonup;": "\u21C0", |
||
9155 | "rightleftarrows;": "\u21C4", |
||
9156 | "rightleftharpoons;": "\u21CC", |
||
9157 | "rightrightarrows;": "\u21C9", |
||
9158 | "rightsquigarrow;": "\u219D", |
||
9159 | "RightTeeArrow;": "\u21A6", |
||
9160 | "RightTee;": "\u22A2", |
||
9161 | "RightTeeVector;": "\u295B", |
||
9162 | "rightthreetimes;": "\u22CC", |
||
9163 | "RightTriangleBar;": "\u29D0", |
||
9164 | "RightTriangle;": "\u22B3", |
||
9165 | "RightTriangleEqual;": "\u22B5", |
||
9166 | "RightUpDownVector;": "\u294F", |
||
9167 | "RightUpTeeVector;": "\u295C", |
||
9168 | "RightUpVectorBar;": "\u2954", |
||
9169 | "RightUpVector;": "\u21BE", |
||
9170 | "RightVectorBar;": "\u2953", |
||
9171 | "RightVector;": "\u21C0", |
||
9172 | "ring;": "\u02DA", |
||
9173 | "risingdotseq;": "\u2253", |
||
9174 | "rlarr;": "\u21C4", |
||
9175 | "rlhar;": "\u21CC", |
||
9176 | "rlm;": "\u200F", |
||
9177 | "rmoustache;": "\u23B1", |
||
9178 | "rmoust;": "\u23B1", |
||
9179 | "rnmid;": "\u2AEE", |
||
9180 | "roang;": "\u27ED", |
||
9181 | "roarr;": "\u21FE", |
||
9182 | "robrk;": "\u27E7", |
||
9183 | "ropar;": "\u2986", |
||
9184 | "ropf;": "\uD835\uDD63", |
||
9185 | "Ropf;": "\u211D", |
||
9186 | "roplus;": "\u2A2E", |
||
9187 | "rotimes;": "\u2A35", |
||
9188 | "RoundImplies;": "\u2970", |
||
9189 | "rpar;": "\u0029", |
||
9190 | "rpargt;": "\u2994", |
||
9191 | "rppolint;": "\u2A12", |
||
9192 | "rrarr;": "\u21C9", |
||
9193 | "Rrightarrow;": "\u21DB", |
||
9194 | "rsaquo;": "\u203A", |
||
9195 | "rscr;": "\uD835\uDCC7", |
||
9196 | "Rscr;": "\u211B", |
||
9197 | "rsh;": "\u21B1", |
||
9198 | "Rsh;": "\u21B1", |
||
9199 | "rsqb;": "\u005D", |
||
9200 | "rsquo;": "\u2019", |
||
9201 | "rsquor;": "\u2019", |
||
9202 | "rthree;": "\u22CC", |
||
9203 | "rtimes;": "\u22CA", |
||
9204 | "rtri;": "\u25B9", |
||
9205 | "rtrie;": "\u22B5", |
||
9206 | "rtrif;": "\u25B8", |
||
9207 | "rtriltri;": "\u29CE", |
||
9208 | "RuleDelayed;": "\u29F4", |
||
9209 | "ruluhar;": "\u2968", |
||
9210 | "rx;": "\u211E", |
||
9211 | "Sacute;": "\u015A", |
||
9212 | "sacute;": "\u015B", |
||
9213 | "sbquo;": "\u201A", |
||
9214 | "scap;": "\u2AB8", |
||
9215 | "Scaron;": "\u0160", |
||
9216 | "scaron;": "\u0161", |
||
9217 | "Sc;": "\u2ABC", |
||
9218 | "sc;": "\u227B", |
||
9219 | "sccue;": "\u227D", |
||
9220 | "sce;": "\u2AB0", |
||
9221 | "scE;": "\u2AB4", |
||
9222 | "Scedil;": "\u015E", |
||
9223 | "scedil;": "\u015F", |
||
9224 | "Scirc;": "\u015C", |
||
9225 | "scirc;": "\u015D", |
||
9226 | "scnap;": "\u2ABA", |
||
9227 | "scnE;": "\u2AB6", |
||
9228 | "scnsim;": "\u22E9", |
||
9229 | "scpolint;": "\u2A13", |
||
9230 | "scsim;": "\u227F", |
||
9231 | "Scy;": "\u0421", |
||
9232 | "scy;": "\u0441", |
||
9233 | "sdotb;": "\u22A1", |
||
9234 | "sdot;": "\u22C5", |
||
9235 | "sdote;": "\u2A66", |
||
9236 | "searhk;": "\u2925", |
||
9237 | "searr;": "\u2198", |
||
9238 | "seArr;": "\u21D8", |
||
9239 | "searrow;": "\u2198", |
||
9240 | "sect;": "\u00A7", |
||
9241 | "sect": "\u00A7", |
||
9242 | "semi;": "\u003B", |
||
9243 | "seswar;": "\u2929", |
||
9244 | "setminus;": "\u2216", |
||
9245 | "setmn;": "\u2216", |
||
9246 | "sext;": "\u2736", |
||
9247 | "Sfr;": "\uD835\uDD16", |
||
9248 | "sfr;": "\uD835\uDD30", |
||
9249 | "sfrown;": "\u2322", |
||
9250 | "sharp;": "\u266F", |
||
9251 | "SHCHcy;": "\u0429", |
||
9252 | "shchcy;": "\u0449", |
||
9253 | "SHcy;": "\u0428", |
||
9254 | "shcy;": "\u0448", |
||
9255 | "ShortDownArrow;": "\u2193", |
||
9256 | "ShortLeftArrow;": "\u2190", |
||
9257 | "shortmid;": "\u2223", |
||
9258 | "shortparallel;": "\u2225", |
||
9259 | "ShortRightArrow;": "\u2192", |
||
9260 | "ShortUpArrow;": "\u2191", |
||
9261 | "shy;": "\u00AD", |
||
9262 | "shy": "\u00AD", |
||
9263 | "Sigma;": "\u03A3", |
||
9264 | "sigma;": "\u03C3", |
||
9265 | "sigmaf;": "\u03C2", |
||
9266 | "sigmav;": "\u03C2", |
||
9267 | "sim;": "\u223C", |
||
9268 | "simdot;": "\u2A6A", |
||
9269 | "sime;": "\u2243", |
||
9270 | "simeq;": "\u2243", |
||
9271 | "simg;": "\u2A9E", |
||
9272 | "simgE;": "\u2AA0", |
||
9273 | "siml;": "\u2A9D", |
||
9274 | "simlE;": "\u2A9F", |
||
9275 | "simne;": "\u2246", |
||
9276 | "simplus;": "\u2A24", |
||
9277 | "simrarr;": "\u2972", |
||
9278 | "slarr;": "\u2190", |
||
9279 | "SmallCircle;": "\u2218", |
||
9280 | "smallsetminus;": "\u2216", |
||
9281 | "smashp;": "\u2A33", |
||
9282 | "smeparsl;": "\u29E4", |
||
9283 | "smid;": "\u2223", |
||
9284 | "smile;": "\u2323", |
||
9285 | "smt;": "\u2AAA", |
||
9286 | "smte;": "\u2AAC", |
||
9287 | "smtes;": "\u2AAC\uFE00", |
||
9288 | "SOFTcy;": "\u042C", |
||
9289 | "softcy;": "\u044C", |
||
9290 | "solbar;": "\u233F", |
||
9291 | "solb;": "\u29C4", |
||
9292 | "sol;": "\u002F", |
||
9293 | "Sopf;": "\uD835\uDD4A", |
||
9294 | "sopf;": "\uD835\uDD64", |
||
9295 | "spades;": "\u2660", |
||
9296 | "spadesuit;": "\u2660", |
||
9297 | "spar;": "\u2225", |
||
9298 | "sqcap;": "\u2293", |
||
9299 | "sqcaps;": "\u2293\uFE00", |
||
9300 | "sqcup;": "\u2294", |
||
9301 | "sqcups;": "\u2294\uFE00", |
||
9302 | "Sqrt;": "\u221A", |
||
9303 | "sqsub;": "\u228F", |
||
9304 | "sqsube;": "\u2291", |
||
9305 | "sqsubset;": "\u228F", |
||
9306 | "sqsubseteq;": "\u2291", |
||
9307 | "sqsup;": "\u2290", |
||
9308 | "sqsupe;": "\u2292", |
||
9309 | "sqsupset;": "\u2290", |
||
9310 | "sqsupseteq;": "\u2292", |
||
9311 | "square;": "\u25A1", |
||
9312 | "Square;": "\u25A1", |
||
9313 | "SquareIntersection;": "\u2293", |
||
9314 | "SquareSubset;": "\u228F", |
||
9315 | "SquareSubsetEqual;": "\u2291", |
||
9316 | "SquareSuperset;": "\u2290", |
||
9317 | "SquareSupersetEqual;": "\u2292", |
||
9318 | "SquareUnion;": "\u2294", |
||
9319 | "squarf;": "\u25AA", |
||
9320 | "squ;": "\u25A1", |
||
9321 | "squf;": "\u25AA", |
||
9322 | "srarr;": "\u2192", |
||
9323 | "Sscr;": "\uD835\uDCAE", |
||
9324 | "sscr;": "\uD835\uDCC8", |
||
9325 | "ssetmn;": "\u2216", |
||
9326 | "ssmile;": "\u2323", |
||
9327 | "sstarf;": "\u22C6", |
||
9328 | "Star;": "\u22C6", |
||
9329 | "star;": "\u2606", |
||
9330 | "starf;": "\u2605", |
||
9331 | "straightepsilon;": "\u03F5", |
||
9332 | "straightphi;": "\u03D5", |
||
9333 | "strns;": "\u00AF", |
||
9334 | "sub;": "\u2282", |
||
9335 | "Sub;": "\u22D0", |
||
9336 | "subdot;": "\u2ABD", |
||
9337 | "subE;": "\u2AC5", |
||
9338 | "sube;": "\u2286", |
||
9339 | "subedot;": "\u2AC3", |
||
9340 | "submult;": "\u2AC1", |
||
9341 | "subnE;": "\u2ACB", |
||
9342 | "subne;": "\u228A", |
||
9343 | "subplus;": "\u2ABF", |
||
9344 | "subrarr;": "\u2979", |
||
9345 | "subset;": "\u2282", |
||
9346 | "Subset;": "\u22D0", |
||
9347 | "subseteq;": "\u2286", |
||
9348 | "subseteqq;": "\u2AC5", |
||
9349 | "SubsetEqual;": "\u2286", |
||
9350 | "subsetneq;": "\u228A", |
||
9351 | "subsetneqq;": "\u2ACB", |
||
9352 | "subsim;": "\u2AC7", |
||
9353 | "subsub;": "\u2AD5", |
||
9354 | "subsup;": "\u2AD3", |
||
9355 | "succapprox;": "\u2AB8", |
||
9356 | "succ;": "\u227B", |
||
9357 | "succcurlyeq;": "\u227D", |
||
9358 | "Succeeds;": "\u227B", |
||
9359 | "SucceedsEqual;": "\u2AB0", |
||
9360 | "SucceedsSlantEqual;": "\u227D", |
||
9361 | "SucceedsTilde;": "\u227F", |
||
9362 | "succeq;": "\u2AB0", |
||
9363 | "succnapprox;": "\u2ABA", |
||
9364 | "succneqq;": "\u2AB6", |
||
9365 | "succnsim;": "\u22E9", |
||
9366 | "succsim;": "\u227F", |
||
9367 | "SuchThat;": "\u220B", |
||
9368 | "sum;": "\u2211", |
||
9369 | "Sum;": "\u2211", |
||
9370 | "sung;": "\u266A", |
||
9371 | "sup1;": "\u00B9", |
||
9372 | "sup1": "\u00B9", |
||
9373 | "sup2;": "\u00B2", |
||
9374 | "sup2": "\u00B2", |
||
9375 | "sup3;": "\u00B3", |
||
9376 | "sup3": "\u00B3", |
||
9377 | "sup;": "\u2283", |
||
9378 | "Sup;": "\u22D1", |
||
9379 | "supdot;": "\u2ABE", |
||
9380 | "supdsub;": "\u2AD8", |
||
9381 | "supE;": "\u2AC6", |
||
9382 | "supe;": "\u2287", |
||
9383 | "supedot;": "\u2AC4", |
||
9384 | "Superset;": "\u2283", |
||
9385 | "SupersetEqual;": "\u2287", |
||
9386 | "suphsol;": "\u27C9", |
||
9387 | "suphsub;": "\u2AD7", |
||
9388 | "suplarr;": "\u297B", |
||
9389 | "supmult;": "\u2AC2", |
||
9390 | "supnE;": "\u2ACC", |
||
9391 | "supne;": "\u228B", |
||
9392 | "supplus;": "\u2AC0", |
||
9393 | "supset;": "\u2283", |
||
9394 | "Supset;": "\u22D1", |
||
9395 | "supseteq;": "\u2287", |
||
9396 | "supseteqq;": "\u2AC6", |
||
9397 | "supsetneq;": "\u228B", |
||
9398 | "supsetneqq;": "\u2ACC", |
||
9399 | "supsim;": "\u2AC8", |
||
9400 | "supsub;": "\u2AD4", |
||
9401 | "supsup;": "\u2AD6", |
||
9402 | "swarhk;": "\u2926", |
||
9403 | "swarr;": "\u2199", |
||
9404 | "swArr;": "\u21D9", |
||
9405 | "swarrow;": "\u2199", |
||
9406 | "swnwar;": "\u292A", |
||
9407 | "szlig;": "\u00DF", |
||
9408 | "szlig": "\u00DF", |
||
9409 | "Tab;": "\u0009", |
||
9410 | "target;": "\u2316", |
||
9411 | "Tau;": "\u03A4", |
||
9412 | "tau;": "\u03C4", |
||
9413 | "tbrk;": "\u23B4", |
||
9414 | "Tcaron;": "\u0164", |
||
9415 | "tcaron;": "\u0165", |
||
9416 | "Tcedil;": "\u0162", |
||
9417 | "tcedil;": "\u0163", |
||
9418 | "Tcy;": "\u0422", |
||
9419 | "tcy;": "\u0442", |
||
9420 | "tdot;": "\u20DB", |
||
9421 | "telrec;": "\u2315", |
||
9422 | "Tfr;": "\uD835\uDD17", |
||
9423 | "tfr;": "\uD835\uDD31", |
||
9424 | "there4;": "\u2234", |
||
9425 | "therefore;": "\u2234", |
||
9426 | "Therefore;": "\u2234", |
||
9427 | "Theta;": "\u0398", |
||
9428 | "theta;": "\u03B8", |
||
9429 | "thetasym;": "\u03D1", |
||
9430 | "thetav;": "\u03D1", |
||
9431 | "thickapprox;": "\u2248", |
||
9432 | "thicksim;": "\u223C", |
||
9433 | "ThickSpace;": "\u205F\u200A", |
||
9434 | "ThinSpace;": "\u2009", |
||
9435 | "thinsp;": "\u2009", |
||
9436 | "thkap;": "\u2248", |
||
9437 | "thksim;": "\u223C", |
||
9438 | "THORN;": "\u00DE", |
||
9439 | "THORN": "\u00DE", |
||
9440 | "thorn;": "\u00FE", |
||
9441 | "thorn": "\u00FE", |
||
9442 | "tilde;": "\u02DC", |
||
9443 | "Tilde;": "\u223C", |
||
9444 | "TildeEqual;": "\u2243", |
||
9445 | "TildeFullEqual;": "\u2245", |
||
9446 | "TildeTilde;": "\u2248", |
||
9447 | "timesbar;": "\u2A31", |
||
9448 | "timesb;": "\u22A0", |
||
9449 | "times;": "\u00D7", |
||
9450 | "times": "\u00D7", |
||
9451 | "timesd;": "\u2A30", |
||
9452 | "tint;": "\u222D", |
||
9453 | "toea;": "\u2928", |
||
9454 | "topbot;": "\u2336", |
||
9455 | "topcir;": "\u2AF1", |
||
9456 | "top;": "\u22A4", |
||
9457 | "Topf;": "\uD835\uDD4B", |
||
9458 | "topf;": "\uD835\uDD65", |
||
9459 | "topfork;": "\u2ADA", |
||
9460 | "tosa;": "\u2929", |
||
9461 | "tprime;": "\u2034", |
||
9462 | "trade;": "\u2122", |
||
9463 | "TRADE;": "\u2122", |
||
9464 | "triangle;": "\u25B5", |
||
9465 | "triangledown;": "\u25BF", |
||
9466 | "triangleleft;": "\u25C3", |
||
9467 | "trianglelefteq;": "\u22B4", |
||
9468 | "triangleq;": "\u225C", |
||
9469 | "triangleright;": "\u25B9", |
||
9470 | "trianglerighteq;": "\u22B5", |
||
9471 | "tridot;": "\u25EC", |
||
9472 | "trie;": "\u225C", |
||
9473 | "triminus;": "\u2A3A", |
||
9474 | "TripleDot;": "\u20DB", |
||
9475 | "triplus;": "\u2A39", |
||
9476 | "trisb;": "\u29CD", |
||
9477 | "tritime;": "\u2A3B", |
||
9478 | "trpezium;": "\u23E2", |
||
9479 | "Tscr;": "\uD835\uDCAF", |
||
9480 | "tscr;": "\uD835\uDCC9", |
||
9481 | "TScy;": "\u0426", |
||
9482 | "tscy;": "\u0446", |
||
9483 | "TSHcy;": "\u040B", |
||
9484 | "tshcy;": "\u045B", |
||
9485 | "Tstrok;": "\u0166", |
||
9486 | "tstrok;": "\u0167", |
||
9487 | "twixt;": "\u226C", |
||
9488 | "twoheadleftarrow;": "\u219E", |
||
9489 | "twoheadrightarrow;": "\u21A0", |
||
9490 | "Uacute;": "\u00DA", |
||
9491 | "Uacute": "\u00DA", |
||
9492 | "uacute;": "\u00FA", |
||
9493 | "uacute": "\u00FA", |
||
9494 | "uarr;": "\u2191", |
||
9495 | "Uarr;": "\u219F", |
||
9496 | "uArr;": "\u21D1", |
||
9497 | "Uarrocir;": "\u2949", |
||
9498 | "Ubrcy;": "\u040E", |
||
9499 | "ubrcy;": "\u045E", |
||
9500 | "Ubreve;": "\u016C", |
||
9501 | "ubreve;": "\u016D", |
||
9502 | "Ucirc;": "\u00DB", |
||
9503 | "Ucirc": "\u00DB", |
||
9504 | "ucirc;": "\u00FB", |
||
9505 | "ucirc": "\u00FB", |
||
9506 | "Ucy;": "\u0423", |
||
9507 | "ucy;": "\u0443", |
||
9508 | "udarr;": "\u21C5", |
||
9509 | "Udblac;": "\u0170", |
||
9510 | "udblac;": "\u0171", |
||
9511 | "udhar;": "\u296E", |
||
9512 | "ufisht;": "\u297E", |
||
9513 | "Ufr;": "\uD835\uDD18", |
||
9514 | "ufr;": "\uD835\uDD32", |
||
9515 | "Ugrave;": "\u00D9", |
||
9516 | "Ugrave": "\u00D9", |
||
9517 | "ugrave;": "\u00F9", |
||
9518 | "ugrave": "\u00F9", |
||
9519 | "uHar;": "\u2963", |
||
9520 | "uharl;": "\u21BF", |
||
9521 | "uharr;": "\u21BE", |
||
9522 | "uhblk;": "\u2580", |
||
9523 | "ulcorn;": "\u231C", |
||
9524 | "ulcorner;": "\u231C", |
||
9525 | "ulcrop;": "\u230F", |
||
9526 | "ultri;": "\u25F8", |
||
9527 | "Umacr;": "\u016A", |
||
9528 | "umacr;": "\u016B", |
||
9529 | "uml;": "\u00A8", |
||
9530 | "uml": "\u00A8", |
||
9531 | "UnderBar;": "\u005F", |
||
9532 | "UnderBrace;": "\u23DF", |
||
9533 | "UnderBracket;": "\u23B5", |
||
9534 | "UnderParenthesis;": "\u23DD", |
||
9535 | "Union;": "\u22C3", |
||
9536 | "UnionPlus;": "\u228E", |
||
9537 | "Uogon;": "\u0172", |
||
9538 | "uogon;": "\u0173", |
||
9539 | "Uopf;": "\uD835\uDD4C", |
||
9540 | "uopf;": "\uD835\uDD66", |
||
9541 | "UpArrowBar;": "\u2912", |
||
9542 | "uparrow;": "\u2191", |
||
9543 | "UpArrow;": "\u2191", |
||
9544 | "Uparrow;": "\u21D1", |
||
9545 | "UpArrowDownArrow;": "\u21C5", |
||
9546 | "updownarrow;": "\u2195", |
||
9547 | "UpDownArrow;": "\u2195", |
||
9548 | "Updownarrow;": "\u21D5", |
||
9549 | "UpEquilibrium;": "\u296E", |
||
9550 | "upharpoonleft;": "\u21BF", |
||
9551 | "upharpoonright;": "\u21BE", |
||
9552 | "uplus;": "\u228E", |
||
9553 | "UpperLeftArrow;": "\u2196", |
||
9554 | "UpperRightArrow;": "\u2197", |
||
9555 | "upsi;": "\u03C5", |
||
9556 | "Upsi;": "\u03D2", |
||
9557 | "upsih;": "\u03D2", |
||
9558 | "Upsilon;": "\u03A5", |
||
9559 | "upsilon;": "\u03C5", |
||
9560 | "UpTeeArrow;": "\u21A5", |
||
9561 | "UpTee;": "\u22A5", |
||
9562 | "upuparrows;": "\u21C8", |
||
9563 | "urcorn;": "\u231D", |
||
9564 | "urcorner;": "\u231D", |
||
9565 | "urcrop;": "\u230E", |
||
9566 | "Uring;": "\u016E", |
||
9567 | "uring;": "\u016F", |
||
9568 | "urtri;": "\u25F9", |
||
9569 | "Uscr;": "\uD835\uDCB0", |
||
9570 | "uscr;": "\uD835\uDCCA", |
||
9571 | "utdot;": "\u22F0", |
||
9572 | "Utilde;": "\u0168", |
||
9573 | "utilde;": "\u0169", |
||
9574 | "utri;": "\u25B5", |
||
9575 | "utrif;": "\u25B4", |
||
9576 | "uuarr;": "\u21C8", |
||
9577 | "Uuml;": "\u00DC", |
||
9578 | "Uuml": "\u00DC", |
||
9579 | "uuml;": "\u00FC", |
||
9580 | "uuml": "\u00FC", |
||
9581 | "uwangle;": "\u29A7", |
||
9582 | "vangrt;": "\u299C", |
||
9583 | "varepsilon;": "\u03F5", |
||
9584 | "varkappa;": "\u03F0", |
||
9585 | "varnothing;": "\u2205", |
||
9586 | "varphi;": "\u03D5", |
||
9587 | "varpi;": "\u03D6", |
||
9588 | "varpropto;": "\u221D", |
||
9589 | "varr;": "\u2195", |
||
9590 | "vArr;": "\u21D5", |
||
9591 | "varrho;": "\u03F1", |
||
9592 | "varsigma;": "\u03C2", |
||
9593 | "varsubsetneq;": "\u228A\uFE00", |
||
9594 | "varsubsetneqq;": "\u2ACB\uFE00", |
||
9595 | "varsupsetneq;": "\u228B\uFE00", |
||
9596 | "varsupsetneqq;": "\u2ACC\uFE00", |
||
9597 | "vartheta;": "\u03D1", |
||
9598 | "vartriangleleft;": "\u22B2", |
||
9599 | "vartriangleright;": "\u22B3", |
||
9600 | "vBar;": "\u2AE8", |
||
9601 | "Vbar;": "\u2AEB", |
||
9602 | "vBarv;": "\u2AE9", |
||
9603 | "Vcy;": "\u0412", |
||
9604 | "vcy;": "\u0432", |
||
9605 | "vdash;": "\u22A2", |
||
9606 | "vDash;": "\u22A8", |
||
9607 | "Vdash;": "\u22A9", |
||
9608 | "VDash;": "\u22AB", |
||
9609 | "Vdashl;": "\u2AE6", |
||
9610 | "veebar;": "\u22BB", |
||
9611 | "vee;": "\u2228", |
||
9612 | "Vee;": "\u22C1", |
||
9613 | "veeeq;": "\u225A", |
||
9614 | "vellip;": "\u22EE", |
||
9615 | "verbar;": "\u007C", |
||
9616 | "Verbar;": "\u2016", |
||
9617 | "vert;": "\u007C", |
||
9618 | "Vert;": "\u2016", |
||
9619 | "VerticalBar;": "\u2223", |
||
9620 | "VerticalLine;": "\u007C", |
||
9621 | "VerticalSeparator;": "\u2758", |
||
9622 | "VerticalTilde;": "\u2240", |
||
9623 | "VeryThinSpace;": "\u200A", |
||
9624 | "Vfr;": "\uD835\uDD19", |
||
9625 | "vfr;": "\uD835\uDD33", |
||
9626 | "vltri;": "\u22B2", |
||
9627 | "vnsub;": "\u2282\u20D2", |
||
9628 | "vnsup;": "\u2283\u20D2", |
||
9629 | "Vopf;": "\uD835\uDD4D", |
||
9630 | "vopf;": "\uD835\uDD67", |
||
9631 | "vprop;": "\u221D", |
||
9632 | "vrtri;": "\u22B3", |
||
9633 | "Vscr;": "\uD835\uDCB1", |
||
9634 | "vscr;": "\uD835\uDCCB", |
||
9635 | "vsubnE;": "\u2ACB\uFE00", |
||
9636 | "vsubne;": "\u228A\uFE00", |
||
9637 | "vsupnE;": "\u2ACC\uFE00", |
||
9638 | "vsupne;": "\u228B\uFE00", |
||
9639 | "Vvdash;": "\u22AA", |
||
9640 | "vzigzag;": "\u299A", |
||
9641 | "Wcirc;": "\u0174", |
||
9642 | "wcirc;": "\u0175", |
||
9643 | "wedbar;": "\u2A5F", |
||
9644 | "wedge;": "\u2227", |
||
9645 | "Wedge;": "\u22C0", |
||
9646 | "wedgeq;": "\u2259", |
||
9647 | "weierp;": "\u2118", |
||
9648 | "Wfr;": "\uD835\uDD1A", |
||
9649 | "wfr;": "\uD835\uDD34", |
||
9650 | "Wopf;": "\uD835\uDD4E", |
||
9651 | "wopf;": "\uD835\uDD68", |
||
9652 | "wp;": "\u2118", |
||
9653 | "wr;": "\u2240", |
||
9654 | "wreath;": "\u2240", |
||
9655 | "Wscr;": "\uD835\uDCB2", |
||
9656 | "wscr;": "\uD835\uDCCC", |
||
9657 | "xcap;": "\u22C2", |
||
9658 | "xcirc;": "\u25EF", |
||
9659 | "xcup;": "\u22C3", |
||
9660 | "xdtri;": "\u25BD", |
||
9661 | "Xfr;": "\uD835\uDD1B", |
||
9662 | "xfr;": "\uD835\uDD35", |
||
9663 | "xharr;": "\u27F7", |
||
9664 | "xhArr;": "\u27FA", |
||
9665 | "Xi;": "\u039E", |
||
9666 | "xi;": "\u03BE", |
||
9667 | "xlarr;": "\u27F5", |
||
9668 | "xlArr;": "\u27F8", |
||
9669 | "xmap;": "\u27FC", |
||
9670 | "xnis;": "\u22FB", |
||
9671 | "xodot;": "\u2A00", |
||
9672 | "Xopf;": "\uD835\uDD4F", |
||
9673 | "xopf;": "\uD835\uDD69", |
||
9674 | "xoplus;": "\u2A01", |
||
9675 | "xotime;": "\u2A02", |
||
9676 | "xrarr;": "\u27F6", |
||
9677 | "xrArr;": "\u27F9", |
||
9678 | "Xscr;": "\uD835\uDCB3", |
||
9679 | "xscr;": "\uD835\uDCCD", |
||
9680 | "xsqcup;": "\u2A06", |
||
9681 | "xuplus;": "\u2A04", |
||
9682 | "xutri;": "\u25B3", |
||
9683 | "xvee;": "\u22C1", |
||
9684 | "xwedge;": "\u22C0", |
||
9685 | "Yacute;": "\u00DD", |
||
9686 | "Yacute": "\u00DD", |
||
9687 | "yacute;": "\u00FD", |
||
9688 | "yacute": "\u00FD", |
||
9689 | "YAcy;": "\u042F", |
||
9690 | "yacy;": "\u044F", |
||
9691 | "Ycirc;": "\u0176", |
||
9692 | "ycirc;": "\u0177", |
||
9693 | "Ycy;": "\u042B", |
||
9694 | "ycy;": "\u044B", |
||
9695 | "yen;": "\u00A5", |
||
9696 | "yen": "\u00A5", |
||
9697 | "Yfr;": "\uD835\uDD1C", |
||
9698 | "yfr;": "\uD835\uDD36", |
||
9699 | "YIcy;": "\u0407", |
||
9700 | "yicy;": "\u0457", |
||
9701 | "Yopf;": "\uD835\uDD50", |
||
9702 | "yopf;": "\uD835\uDD6A", |
||
9703 | "Yscr;": "\uD835\uDCB4", |
||
9704 | "yscr;": "\uD835\uDCCE", |
||
9705 | "YUcy;": "\u042E", |
||
9706 | "yucy;": "\u044E", |
||
9707 | "yuml;": "\u00FF", |
||
9708 | "yuml": "\u00FF", |
||
9709 | "Yuml;": "\u0178", |
||
9710 | "Zacute;": "\u0179", |
||
9711 | "zacute;": "\u017A", |
||
9712 | "Zcaron;": "\u017D", |
||
9713 | "zcaron;": "\u017E", |
||
9714 | "Zcy;": "\u0417", |
||
9715 | "zcy;": "\u0437", |
||
9716 | "Zdot;": "\u017B", |
||
9717 | "zdot;": "\u017C", |
||
9718 | "zeetrf;": "\u2128", |
||
9719 | "ZeroWidthSpace;": "\u200B", |
||
9720 | "Zeta;": "\u0396", |
||
9721 | "zeta;": "\u03B6", |
||
9722 | "zfr;": "\uD835\uDD37", |
||
9723 | "Zfr;": "\u2128", |
||
9724 | "ZHcy;": "\u0416", |
||
9725 | "zhcy;": "\u0436", |
||
9726 | "zigrarr;": "\u21DD", |
||
9727 | "zopf;": "\uD835\uDD6B", |
||
9728 | "Zopf;": "\u2124", |
||
9729 | "Zscr;": "\uD835\uDCB5", |
||
9730 | "zscr;": "\uD835\uDCCF", |
||
9731 | "zwj;": "\u200D", |
||
9732 | "zwnj;": "\u200C" |
||
9733 | }; |
||
9734 | |||
9735 | }, |
||
9736 | {}], |
||
9737 | 13:[function(_dereq_,module,exports){ |
||
9738 | var util = _dereq_('util/'); |
||
9739 | |||
9740 | var pSlice = Array.prototype.slice; |
||
9741 | var hasOwn = Object.prototype.hasOwnProperty; |
||
9742 | |||
9743 | var assert = module.exports = ok; |
||
9744 | |||
9745 | assert.AssertionError = function AssertionError(options) { |
||
9746 | this.name = 'AssertionError'; |
||
9747 | this.actual = options.actual; |
||
9748 | this.expected = options.expected; |
||
9749 | this.operator = options.operator; |
||
9750 | if (options.message) { |
||
9751 | this.message = options.message; |
||
9752 | this.generatedMessage = false; |
||
9753 | } else { |
||
9754 | this.message = getMessage(this); |
||
9755 | this.generatedMessage = true; |
||
9756 | } |
||
9757 | var stackStartFunction = options.stackStartFunction || fail; |
||
9758 | |||
9759 | if (Error.captureStackTrace) { |
||
9760 | Error.captureStackTrace(this, stackStartFunction); |
||
9761 | } |
||
9762 | else { |
||
9763 | var err = new Error(); |
||
9764 | if (err.stack) { |
||
9765 | var out = err.stack; |
||
9766 | var fn_name = stackStartFunction.name; |
||
9767 | var idx = out.indexOf('\n' + fn_name); |
||
9768 | if (idx >= 0) { |
||
9769 | var next_line = out.indexOf('\n', idx + 1); |
||
9770 | out = out.substring(next_line + 1); |
||
9771 | } |
||
9772 | |||
9773 | this.stack = out; |
||
9774 | } |
||
9775 | } |
||
9776 | }; |
||
9777 | util.inherits(assert.AssertionError, Error); |
||
9778 | |||
9779 | function replacer(key, value) { |
||
9780 | if (util.isUndefined(value)) { |
||
9781 | return '' + value; |
||
9782 | } |
||
9783 | if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) { |
||
9784 | return value.toString(); |
||
9785 | } |
||
9786 | if (util.isFunction(value) || util.isRegExp(value)) { |
||
9787 | return value.toString(); |
||
9788 | } |
||
9789 | return value; |
||
9790 | } |
||
9791 | |||
9792 | function truncate(s, n) { |
||
9793 | if (util.isString(s)) { |
||
9794 | return s.length < n ? s : s.slice(0, n); |
||
9795 | } else { |
||
9796 | return s; |
||
9797 | } |
||
9798 | } |
||
9799 | |||
9800 | function getMessage(self) { |
||
9801 | return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' + |
||
9802 | self.operator + ' ' + |
||
9803 | truncate(JSON.stringify(self.expected, replacer), 128); |
||
9804 | } |
||
9805 | |||
9806 | function fail(actual, expected, message, operator, stackStartFunction) { |
||
9807 | throw new assert.AssertionError({ |
||
9808 | message: message, |
||
9809 | actual: actual, |
||
9810 | expected: expected, |
||
9811 | operator: operator, |
||
9812 | stackStartFunction: stackStartFunction |
||
9813 | }); |
||
9814 | } |
||
9815 | assert.fail = fail; |
||
9816 | |||
9817 | function ok(value, message) { |
||
9818 | if (!value) fail(value, true, message, '==', assert.ok); |
||
9819 | } |
||
9820 | assert.ok = ok; |
||
9821 | |||
9822 | assert.equal = function equal(actual, expected, message) { |
||
9823 | if (actual != expected) fail(actual, expected, message, '==', assert.equal); |
||
9824 | }; |
||
9825 | |||
9826 | assert.notEqual = function notEqual(actual, expected, message) { |
||
9827 | if (actual == expected) { |
||
9828 | fail(actual, expected, message, '!=', assert.notEqual); |
||
9829 | } |
||
9830 | }; |
||
9831 | |||
9832 | assert.deepEqual = function deepEqual(actual, expected, message) { |
||
9833 | if (!_deepEqual(actual, expected)) { |
||
9834 | fail(actual, expected, message, 'deepEqual', assert.deepEqual); |
||
9835 | } |
||
9836 | }; |
||
9837 | |||
9838 | function _deepEqual(actual, expected) { |
||
9839 | if (actual === expected) { |
||
9840 | return true; |
||
9841 | |||
9842 | } else if (util.isBuffer(actual) && util.isBuffer(expected)) { |
||
9843 | if (actual.length != expected.length) return false; |
||
9844 | |||
9845 | for (var i = 0; i < actual.length; i++) { |
||
9846 | if (actual[i] !== expected[i]) return false; |
||
9847 | } |
||
9848 | |||
9849 | return true; |
||
9850 | } else if (util.isDate(actual) && util.isDate(expected)) { |
||
9851 | return actual.getTime() === expected.getTime(); |
||
9852 | } else if (util.isRegExp(actual) && util.isRegExp(expected)) { |
||
9853 | return actual.source === expected.source && |
||
9854 | actual.global === expected.global && |
||
9855 | actual.multiline === expected.multiline && |
||
9856 | actual.lastIndex === expected.lastIndex && |
||
9857 | actual.ignoreCase === expected.ignoreCase; |
||
9858 | } else if (!util.isObject(actual) && !util.isObject(expected)) { |
||
9859 | return actual == expected; |
||
9860 | } else { |
||
9861 | return objEquiv(actual, expected); |
||
9862 | } |
||
9863 | } |
||
9864 | |||
9865 | function isArguments(object) { |
||
9866 | return Object.prototype.toString.call(object) == '[object Arguments]'; |
||
9867 | } |
||
9868 | |||
9869 | function objEquiv(a, b) { |
||
9870 | if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b)) |
||
9871 | return false; |
||
9872 | if (a.prototype !== b.prototype) return false; |
||
9873 | if (isArguments(a)) { |
||
9874 | if (!isArguments(b)) { |
||
9875 | return false; |
||
9876 | } |
||
9877 | a = pSlice.call(a); |
||
9878 | b = pSlice.call(b); |
||
9879 | return _deepEqual(a, b); |
||
9880 | } |
||
9881 | try { |
||
9882 | var ka = objectKeys(a), |
||
9883 | kb = objectKeys(b), |
||
9884 | key, i; |
||
9885 | } catch (e) {//happens when one is a string literal and the other isn't |
||
9886 | return false; |
||
9887 | } |
||
9888 | if (ka.length != kb.length) |
||
9889 | return false; |
||
9890 | ka.sort(); |
||
9891 | kb.sort(); |
||
9892 | for (i = ka.length - 1; i >= 0; i--) { |
||
9893 | if (ka[i] != kb[i]) |
||
9894 | return false; |
||
9895 | } |
||
9896 | for (i = ka.length - 1; i >= 0; i--) { |
||
9897 | key = ka[i]; |
||
9898 | if (!_deepEqual(a[key], b[key])) return false; |
||
9899 | } |
||
9900 | return true; |
||
9901 | } |
||
9902 | |||
9903 | assert.notDeepEqual = function notDeepEqual(actual, expected, message) { |
||
9904 | if (_deepEqual(actual, expected)) { |
||
9905 | fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); |
||
9906 | } |
||
9907 | }; |
||
9908 | |||
9909 | assert.strictEqual = function strictEqual(actual, expected, message) { |
||
9910 | if (actual !== expected) { |
||
9911 | fail(actual, expected, message, '===', assert.strictEqual); |
||
9912 | } |
||
9913 | }; |
||
9914 | |||
9915 | assert.notStrictEqual = function notStrictEqual(actual, expected, message) { |
||
9916 | if (actual === expected) { |
||
9917 | fail(actual, expected, message, '!==', assert.notStrictEqual); |
||
9918 | } |
||
9919 | }; |
||
9920 | |||
9921 | function expectedException(actual, expected) { |
||
9922 | if (!actual || !expected) { |
||
9923 | return false; |
||
9924 | } |
||
9925 | |||
9926 | if (Object.prototype.toString.call(expected) == '[object RegExp]') { |
||
9927 | return expected.test(actual); |
||
9928 | } else if (actual instanceof expected) { |
||
9929 | return true; |
||
9930 | } else if (expected.call({}, actual) === true) { |
||
9931 | return true; |
||
9932 | } |
||
9933 | |||
9934 | return false; |
||
9935 | } |
||
9936 | |||
9937 | function _throws(shouldThrow, block, expected, message) { |
||
9938 | var actual; |
||
9939 | |||
9940 | if (util.isString(expected)) { |
||
9941 | message = expected; |
||
9942 | expected = null; |
||
9943 | } |
||
9944 | |||
9945 | try { |
||
9946 | block(); |
||
9947 | } catch (e) { |
||
9948 | actual = e; |
||
9949 | } |
||
9950 | |||
9951 | message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + |
||
9952 | (message ? ' ' + message : '.'); |
||
9953 | |||
9954 | if (shouldThrow && !actual) { |
||
9955 | fail(actual, expected, 'Missing expected exception' + message); |
||
9956 | } |
||
9957 | |||
9958 | if (!shouldThrow && expectedException(actual, expected)) { |
||
9959 | fail(actual, expected, 'Got unwanted exception' + message); |
||
9960 | } |
||
9961 | |||
9962 | if ((shouldThrow && actual && expected && |
||
9963 | !expectedException(actual, expected)) || (!shouldThrow && actual)) { |
||
9964 | throw actual; |
||
9965 | } |
||
9966 | } |
||
9967 | |||
9968 | assert.throws = function(block, /*optional*/error, /*optional*/message) { |
||
9969 | _throws.apply(this, [true].concat(pSlice.call(arguments))); |
||
9970 | }; |
||
9971 | assert.doesNotThrow = function(block, /*optional*/message) { |
||
9972 | _throws.apply(this, [false].concat(pSlice.call(arguments))); |
||
9973 | }; |
||
9974 | |||
9975 | assert.ifError = function(err) { if (err) {throw err;}}; |
||
9976 | |||
9977 | var objectKeys = Object.keys || function (obj) { |
||
9978 | var keys = []; |
||
9979 | for (var key in obj) { |
||
9980 | if (hasOwn.call(obj, key)) keys.push(key); |
||
9981 | } |
||
9982 | return keys; |
||
9983 | }; |
||
9984 | |||
9985 | }, |
||
9986 | {"util/":15}], |
||
9987 | 14:[function(_dereq_,module,exports){ |
||
9988 | module.exports = function isBuffer(arg) { |
||
9989 | return arg && typeof arg === 'object' |
||
9990 | && typeof arg.copy === 'function' |
||
9991 | && typeof arg.fill === 'function' |
||
9992 | && typeof arg.readUInt8 === 'function'; |
||
9993 | } |
||
9994 | }, |
||
9995 | {}], |
||
9996 | 15:[function(_dereq_,module,exports){ |
||
9997 | (function (process,global){ |
||
9998 | |||
9999 | var formatRegExp = /%[sdj%]/g; |
||
10000 | exports.format = function(f) { |
||
10001 | if (!isString(f)) { |
||
10002 | var objects = []; |
||
10003 | for (var i = 0; i < arguments.length; i++) { |
||
10004 | objects.push(inspect(arguments[i])); |
||
10005 | } |
||
10006 | return objects.join(' '); |
||
10007 | } |
||
10008 | |||
10009 | var i = 1; |
||
10010 | var args = arguments; |
||
10011 | var len = args.length; |
||
10012 | var str = String(f).replace(formatRegExp, function(x) { |
||
10013 | if (x === '%%') return '%'; |
||
10014 | if (i >= len) return x; |
||
10015 | switch (x) { |
||
10016 | case '%s': return String(args[i++]); |
||
10017 | case '%d': return Number(args[i++]); |
||
10018 | case '%j': |
||
10019 | try { |
||
10020 | return JSON.stringify(args[i++]); |
||
10021 | } catch (_) { |
||
10022 | return '[Circular]'; |
||
10023 | } |
||
10024 | default: |
||
10025 | return x; |
||
10026 | } |
||
10027 | }); |
||
10028 | for (var x = args[i]; i < len; x = args[++i]) { |
||
10029 | if (isNull(x) || !isObject(x)) { |
||
10030 | str += ' ' + x; |
||
10031 | } else { |
||
10032 | str += ' ' + inspect(x); |
||
10033 | } |
||
10034 | } |
||
10035 | return str; |
||
10036 | }; |
||
10037 | exports.deprecate = function(fn, msg) { |
||
10038 | if (isUndefined(global.process)) { |
||
10039 | return function() { |
||
10040 | return exports.deprecate(fn, msg).apply(this, arguments); |
||
10041 | }; |
||
10042 | } |
||
10043 | |||
10044 | if (process.noDeprecation === true) { |
||
10045 | return fn; |
||
10046 | } |
||
10047 | |||
10048 | var warned = false; |
||
10049 | function deprecated() { |
||
10050 | if (!warned) { |
||
10051 | if (process.throwDeprecation) { |
||
10052 | throw new Error(msg); |
||
10053 | } else if (process.traceDeprecation) { |
||
10054 | console.trace(msg); |
||
10055 | } else { |
||
10056 | console.error(msg); |
||
10057 | } |
||
10058 | warned = true; |
||
10059 | } |
||
10060 | return fn.apply(this, arguments); |
||
10061 | } |
||
10062 | |||
10063 | return deprecated; |
||
10064 | }; |
||
10065 | |||
10066 | |||
10067 | var debugs = {}; |
||
10068 | var debugEnviron; |
||
10069 | exports.debuglog = function(set) { |
||
10070 | if (isUndefined(debugEnviron)) |
||
10071 | debugEnviron = process.env.NODE_DEBUG || ''; |
||
10072 | set = set.toUpperCase(); |
||
10073 | if (!debugs[set]) { |
||
10074 | if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { |
||
10075 | var pid = process.pid; |
||
10076 | debugs[set] = function() { |
||
10077 | var msg = exports.format.apply(exports, arguments); |
||
10078 | console.error('%s %d: %s', set, pid, msg); |
||
10079 | }; |
||
10080 | } else { |
||
10081 | debugs[set] = function() {}; |
||
10082 | } |
||
10083 | } |
||
10084 | return debugs[set]; |
||
10085 | }; |
||
10086 | function inspect(obj, opts) { |
||
10087 | var ctx = { |
||
10088 | seen: [], |
||
10089 | stylize: stylizeNoColor |
||
10090 | }; |
||
10091 | if (arguments.length >= 3) ctx.depth = arguments[2]; |
||
10092 | if (arguments.length >= 4) ctx.colors = arguments[3]; |
||
10093 | if (isBoolean(opts)) { |
||
10094 | ctx.showHidden = opts; |
||
10095 | } else if (opts) { |
||
10096 | exports._extend(ctx, opts); |
||
10097 | } |
||
10098 | if (isUndefined(ctx.showHidden)) ctx.showHidden = false; |
||
10099 | if (isUndefined(ctx.depth)) ctx.depth = 2; |
||
10100 | if (isUndefined(ctx.colors)) ctx.colors = false; |
||
10101 | if (isUndefined(ctx.customInspect)) ctx.customInspect = true; |
||
10102 | if (ctx.colors) ctx.stylize = stylizeWithColor; |
||
10103 | return formatValue(ctx, obj, ctx.depth); |
||
10104 | } |
||
10105 | exports.inspect = inspect; |
||
10106 | inspect.colors = { |
||
10107 | 'bold' : [1, 22], |
||
10108 | 'italic' : [3, 23], |
||
10109 | 'underline' : [4, 24], |
||
10110 | 'inverse' : [7, 27], |
||
10111 | 'white' : [37, 39], |
||
10112 | 'grey' : [90, 39], |
||
10113 | 'black' : [30, 39], |
||
10114 | 'blue' : [34, 39], |
||
10115 | 'cyan' : [36, 39], |
||
10116 | 'green' : [32, 39], |
||
10117 | 'magenta' : [35, 39], |
||
10118 | 'red' : [31, 39], |
||
10119 | 'yellow' : [33, 39] |
||
10120 | }; |
||
10121 | inspect.styles = { |
||
10122 | 'special': 'cyan', |
||
10123 | 'number': 'yellow', |
||
10124 | 'boolean': 'yellow', |
||
10125 | 'undefined': 'grey', |
||
10126 | 'null': 'bold', |
||
10127 | 'string': 'green', |
||
10128 | 'date': 'magenta', |
||
10129 | 'regexp': 'red' |
||
10130 | }; |
||
10131 | |||
10132 | |||
10133 | function stylizeWithColor(str, styleType) { |
||
10134 | var style = inspect.styles[styleType]; |
||
10135 | |||
10136 | if (style) { |
||
10137 | return '\u001b[' + inspect.colors[style][0] + 'm' + str + |
||
10138 | '\u001b[' + inspect.colors[style][1] + 'm'; |
||
10139 | } else { |
||
10140 | return str; |
||
10141 | } |
||
10142 | } |
||
10143 | |||
10144 | |||
10145 | function stylizeNoColor(str, styleType) { |
||
10146 | return str; |
||
10147 | } |
||
10148 | |||
10149 | |||
10150 | function arrayToHash(array) { |
||
10151 | var hash = {}; |
||
10152 | |||
10153 | array.forEach(function(val, idx) { |
||
10154 | hash[val] = true; |
||
10155 | }); |
||
10156 | |||
10157 | return hash; |
||
10158 | } |
||
10159 | |||
10160 | |||
10161 | function formatValue(ctx, value, recurseTimes) { |
||
10162 | if (ctx.customInspect && |
||
10163 | value && |
||
10164 | isFunction(value.inspect) && |
||
10165 | value.inspect !== exports.inspect && |
||
10166 | !(value.constructor && value.constructor.prototype === value)) { |
||
10167 | var ret = value.inspect(recurseTimes, ctx); |
||
10168 | if (!isString(ret)) { |
||
10169 | ret = formatValue(ctx, ret, recurseTimes); |
||
10170 | } |
||
10171 | return ret; |
||
10172 | } |
||
10173 | var primitive = formatPrimitive(ctx, value); |
||
10174 | if (primitive) { |
||
10175 | return primitive; |
||
10176 | } |
||
10177 | var keys = Object.keys(value); |
||
10178 | var visibleKeys = arrayToHash(keys); |
||
10179 | |||
10180 | if (ctx.showHidden) { |
||
10181 | keys = Object.getOwnPropertyNames(value); |
||
10182 | } |
||
10183 | if (isError(value) |
||
10184 | && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { |
||
10185 | return formatError(value); |
||
10186 | } |
||
10187 | if (keys.length === 0) { |
||
10188 | if (isFunction(value)) { |
||
10189 | var name = value.name ? ': ' + value.name : ''; |
||
10190 | return ctx.stylize('[Function' + name + ']', 'special'); |
||
10191 | } |
||
10192 | if (isRegExp(value)) { |
||
10193 | return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); |
||
10194 | } |
||
10195 | if (isDate(value)) { |
||
10196 | return ctx.stylize(Date.prototype.toString.call(value), 'date'); |
||
10197 | } |
||
10198 | if (isError(value)) { |
||
10199 | return formatError(value); |
||
10200 | } |
||
10201 | } |
||
10202 | |||
10203 | var base = '', array = false, braces = ['{', '}']; |
||
10204 | if (isArray(value)) { |
||
10205 | array = true; |
||
10206 | braces = ['[', ']']; |
||
10207 | } |
||
10208 | if (isFunction(value)) { |
||
10209 | var n = value.name ? ': ' + value.name : ''; |
||
10210 | base = ' [Function' + n + ']'; |
||
10211 | } |
||
10212 | if (isRegExp(value)) { |
||
10213 | base = ' ' + RegExp.prototype.toString.call(value); |
||
10214 | } |
||
10215 | if (isDate(value)) { |
||
10216 | base = ' ' + Date.prototype.toUTCString.call(value); |
||
10217 | } |
||
10218 | if (isError(value)) { |
||
10219 | base = ' ' + formatError(value); |
||
10220 | } |
||
10221 | |||
10222 | if (keys.length === 0 && (!array || value.length == 0)) { |
||
10223 | return braces[0] + base + braces[1]; |
||
10224 | } |
||
10225 | |||
10226 | if (recurseTimes < 0) { |
||
10227 | if (isRegExp(value)) { |
||
10228 | return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); |
||
10229 | } else { |
||
10230 | return ctx.stylize('[Object]', 'special'); |
||
10231 | } |
||
10232 | } |
||
10233 | |||
10234 | ctx.seen.push(value); |
||
10235 | |||
10236 | var output; |
||
10237 | if (array) { |
||
10238 | output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); |
||
10239 | } else { |
||
10240 | output = keys.map(function(key) { |
||
10241 | return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); |
||
10242 | }); |
||
10243 | } |
||
10244 | |||
10245 | ctx.seen.pop(); |
||
10246 | |||
10247 | return reduceToSingleString(output, base, braces); |
||
10248 | } |
||
10249 | |||
10250 | |||
10251 | function formatPrimitive(ctx, value) { |
||
10252 | if (isUndefined(value)) |
||
10253 | return ctx.stylize('undefined', 'undefined'); |
||
10254 | if (isString(value)) { |
||
10255 | var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') |
||
10256 | .replace(/'/g, "\\'") |
||
10257 | .replace(/\\"/g, '"') + '\''; |
||
10258 | return ctx.stylize(simple, 'string'); |
||
10259 | } |
||
10260 | if (isNumber(value)) |
||
10261 | return ctx.stylize('' + value, 'number'); |
||
10262 | if (isBoolean(value)) |
||
10263 | return ctx.stylize('' + value, 'boolean'); |
||
10264 | if (isNull(value)) |
||
10265 | return ctx.stylize('null', 'null'); |
||
10266 | } |
||
10267 | |||
10268 | |||
10269 | function formatError(value) { |
||
10270 | return '[' + Error.prototype.toString.call(value) + ']'; |
||
10271 | } |
||
10272 | |||
10273 | |||
10274 | function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { |
||
10275 | var output = []; |
||
10276 | for (var i = 0, l = value.length; i < l; ++i) { |
||
10277 | if (hasOwnProperty(value, String(i))) { |
||
10278 | output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, |
||
10279 | String(i), true)); |
||
10280 | } else { |
||
10281 | output.push(''); |
||
10282 | } |
||
10283 | } |
||
10284 | keys.forEach(function(key) { |
||
10285 | if (!key.match(/^\d+$/)) { |
||
10286 | output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, |
||
10287 | key, true)); |
||
10288 | } |
||
10289 | }); |
||
10290 | return output; |
||
10291 | } |
||
10292 | |||
10293 | |||
10294 | function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { |
||
10295 | var name, str, desc; |
||
10296 | desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; |
||
10297 | if (desc.get) { |
||
10298 | if (desc.set) { |
||
10299 | str = ctx.stylize('[Getter/Setter]', 'special'); |
||
10300 | } else { |
||
10301 | str = ctx.stylize('[Getter]', 'special'); |
||
10302 | } |
||
10303 | } else { |
||
10304 | if (desc.set) { |
||
10305 | str = ctx.stylize('[Setter]', 'special'); |
||
10306 | } |
||
10307 | } |
||
10308 | if (!hasOwnProperty(visibleKeys, key)) { |
||
10309 | name = '[' + key + ']'; |
||
10310 | } |
||
10311 | if (!str) { |
||
10312 | if (ctx.seen.indexOf(desc.value) < 0) { |
||
10313 | if (isNull(recurseTimes)) { |
||
10314 | str = formatValue(ctx, desc.value, null); |
||
10315 | } else { |
||
10316 | str = formatValue(ctx, desc.value, recurseTimes - 1); |
||
10317 | } |
||
10318 | if (str.indexOf('\n') > -1) { |
||
10319 | if (array) { |
||
10320 | str = str.split('\n').map(function(line) { |
||
10321 | return ' ' + line; |
||
10322 | }).join('\n').substr(2); |
||
10323 | } else { |
||
10324 | str = '\n' + str.split('\n').map(function(line) { |
||
10325 | return ' ' + line; |
||
10326 | }).join('\n'); |
||
10327 | } |
||
10328 | } |
||
10329 | } else { |
||
10330 | str = ctx.stylize('[Circular]', 'special'); |
||
10331 | } |
||
10332 | } |
||
10333 | if (isUndefined(name)) { |
||
10334 | if (array && key.match(/^\d+$/)) { |
||
10335 | return str; |
||
10336 | } |
||
10337 | name = JSON.stringify('' + key); |
||
10338 | if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { |
||
10339 | name = name.substr(1, name.length - 2); |
||
10340 | name = ctx.stylize(name, 'name'); |
||
10341 | } else { |
||
10342 | name = name.replace(/'/g, "\\'") |
||
10343 | .replace(/\\"/g, '"') |
||
10344 | .replace(/(^"|"$)/g, "'"); |
||
10345 | name = ctx.stylize(name, 'string'); |
||
10346 | } |
||
10347 | } |
||
10348 | |||
10349 | return name + ': ' + str; |
||
10350 | } |
||
10351 | |||
10352 | |||
10353 | function reduceToSingleString(output, base, braces) { |
||
10354 | var numLinesEst = 0; |
||
10355 | var length = output.reduce(function(prev, cur) { |
||
10356 | numLinesEst++; |
||
10357 | if (cur.indexOf('\n') >= 0) numLinesEst++; |
||
10358 | return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; |
||
10359 | }, 0); |
||
10360 | |||
10361 | if (length > 60) { |
||
10362 | return braces[0] + |
||
10363 | (base === '' ? '' : base + '\n ') + |
||
10364 | ' ' + |
||
10365 | output.join(',\n ') + |
||
10366 | ' ' + |
||
10367 | braces[1]; |
||
10368 | } |
||
10369 | |||
10370 | return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; |
||
10371 | } |
||
10372 | function isArray(ar) { |
||
10373 | return Array.isArray(ar); |
||
10374 | } |
||
10375 | exports.isArray = isArray; |
||
10376 | |||
10377 | function isBoolean(arg) { |
||
10378 | return typeof arg === 'boolean'; |
||
10379 | } |
||
10380 | exports.isBoolean = isBoolean; |
||
10381 | |||
10382 | function isNull(arg) { |
||
10383 | return arg === null; |
||
10384 | } |
||
10385 | exports.isNull = isNull; |
||
10386 | |||
10387 | function isNullOrUndefined(arg) { |
||
10388 | return arg == null; |
||
10389 | } |
||
10390 | exports.isNullOrUndefined = isNullOrUndefined; |
||
10391 | |||
10392 | function isNumber(arg) { |
||
10393 | return typeof arg === 'number'; |
||
10394 | } |
||
10395 | exports.isNumber = isNumber; |
||
10396 | |||
10397 | function isString(arg) { |
||
10398 | return typeof arg === 'string'; |
||
10399 | } |
||
10400 | exports.isString = isString; |
||
10401 | |||
10402 | function isSymbol(arg) { |
||
10403 | return typeof arg === 'symbol'; |
||
10404 | } |
||
10405 | exports.isSymbol = isSymbol; |
||
10406 | |||
10407 | function isUndefined(arg) { |
||
10408 | return arg === void 0; |
||
10409 | } |
||
10410 | exports.isUndefined = isUndefined; |
||
10411 | |||
10412 | function isRegExp(re) { |
||
10413 | return isObject(re) && objectToString(re) === '[object RegExp]'; |
||
10414 | } |
||
10415 | exports.isRegExp = isRegExp; |
||
10416 | |||
10417 | function isObject(arg) { |
||
10418 | return typeof arg === 'object' && arg !== null; |
||
10419 | } |
||
10420 | exports.isObject = isObject; |
||
10421 | |||
10422 | function isDate(d) { |
||
10423 | return isObject(d) && objectToString(d) === '[object Date]'; |
||
10424 | } |
||
10425 | exports.isDate = isDate; |
||
10426 | |||
10427 | function isError(e) { |
||
10428 | return isObject(e) && |
||
10429 | (objectToString(e) === '[object Error]' || e instanceof Error); |
||
10430 | } |
||
10431 | exports.isError = isError; |
||
10432 | |||
10433 | function isFunction(arg) { |
||
10434 | return typeof arg === 'function'; |
||
10435 | } |
||
10436 | exports.isFunction = isFunction; |
||
10437 | |||
10438 | function isPrimitive(arg) { |
||
10439 | return arg === null || |
||
10440 | typeof arg === 'boolean' || |
||
10441 | typeof arg === 'number' || |
||
10442 | typeof arg === 'string' || |
||
10443 | typeof arg === 'symbol' || // ES6 symbol |
||
10444 | typeof arg === 'undefined'; |
||
10445 | } |
||
10446 | exports.isPrimitive = isPrimitive; |
||
10447 | |||
10448 | exports.isBuffer = _dereq_('./support/isBuffer'); |
||
10449 | |||
10450 | function objectToString(o) { |
||
10451 | return Object.prototype.toString.call(o); |
||
10452 | } |
||
10453 | |||
10454 | |||
10455 | function pad(n) { |
||
10456 | return n < 10 ? '0' + n.toString(10) : n.toString(10); |
||
10457 | } |
||
10458 | |||
10459 | |||
10460 | var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', |
||
10461 | 'Oct', 'Nov', 'Dec']; |
||
10462 | function timestamp() { |
||
10463 | var d = new Date(); |
||
10464 | var time = [pad(d.getHours()), |
||
10465 | pad(d.getMinutes()), |
||
10466 | pad(d.getSeconds())].join(':'); |
||
10467 | return [d.getDate(), months[d.getMonth()], time].join(' '); |
||
10468 | } |
||
10469 | exports.log = function() { |
||
10470 | console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); |
||
10471 | }; |
||
10472 | exports.inherits = _dereq_('inherits'); |
||
10473 | |||
10474 | exports._extend = function(origin, add) { |
||
10475 | if (!add || !isObject(add)) return origin; |
||
10476 | |||
10477 | var keys = Object.keys(add); |
||
10478 | var i = keys.length; |
||
10479 | while (i--) { |
||
10480 | origin[keys[i]] = add[keys[i]]; |
||
10481 | } |
||
10482 | return origin; |
||
10483 | }; |
||
10484 | |||
10485 | function hasOwnProperty(obj, prop) { |
||
10486 | return Object.prototype.hasOwnProperty.call(obj, prop); |
||
10487 | } |
||
10488 | |||
10489 | }).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 : {}) |
||
10490 | }, |
||
10491 | {"./support/isBuffer":14,"/usr/local/lib/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":18,"inherits":17}], |
||
10492 | 16:[function(_dereq_,module,exports){ |
||
10493 | |||
10494 | function EventEmitter() { |
||
10495 | this._events = this._events || {}; |
||
10496 | this._maxListeners = this._maxListeners || undefined; |
||
10497 | } |
||
10498 | module.exports = EventEmitter; |
||
10499 | EventEmitter.EventEmitter = EventEmitter; |
||
10500 | |||
10501 | EventEmitter.prototype._events = undefined; |
||
10502 | EventEmitter.prototype._maxListeners = undefined; |
||
10503 | EventEmitter.defaultMaxListeners = 10; |
||
10504 | EventEmitter.prototype.setMaxListeners = function(n) { |
||
10505 | if (!isNumber(n) || n < 0 || isNaN(n)) |
||
10506 | throw TypeError('n must be a positive number'); |
||
10507 | this._maxListeners = n; |
||
10508 | return this; |
||
10509 | }; |
||
10510 | |||
10511 | EventEmitter.prototype.emit = function(type) { |
||
10512 | var er, handler, len, args, i, listeners; |
||
10513 | |||
10514 | if (!this._events) |
||
10515 | this._events = {}; |
||
10516 | if (type === 'error') { |
||
10517 | if (!this._events.error || |
||
10518 | (isObject(this._events.error) && !this._events.error.length)) { |
||
10519 | er = arguments[1]; |
||
10520 | if (er instanceof Error) { |
||
10521 | throw er; // Unhandled 'error' event |
||
10522 | } else { |
||
10523 | throw TypeError('Uncaught, unspecified "error" event.'); |
||
10524 | } |
||
10525 | return false; |
||
10526 | } |
||
10527 | } |
||
10528 | |||
10529 | handler = this._events[type]; |
||
10530 | |||
10531 | if (isUndefined(handler)) |
||
10532 | return false; |
||
10533 | |||
10534 | if (isFunction(handler)) { |
||
10535 | switch (arguments.length) { |
||
10536 | case 1: |
||
10537 | handler.call(this); |
||
10538 | break; |
||
10539 | case 2: |
||
10540 | handler.call(this, arguments[1]); |
||
10541 | break; |
||
10542 | case 3: |
||
10543 | handler.call(this, arguments[1], arguments[2]); |
||
10544 | break; |
||
10545 | default: |
||
10546 | len = arguments.length; |
||
10547 | args = new Array(len - 1); |
||
10548 | for (i = 1; i < len; i++) |
||
10549 | args[i - 1] = arguments[i]; |
||
10550 | handler.apply(this, args); |
||
10551 | } |
||
10552 | } else if (isObject(handler)) { |
||
10553 | len = arguments.length; |
||
10554 | args = new Array(len - 1); |
||
10555 | for (i = 1; i < len; i++) |
||
10556 | args[i - 1] = arguments[i]; |
||
10557 | |||
10558 | listeners = handler.slice(); |
||
10559 | len = listeners.length; |
||
10560 | for (i = 0; i < len; i++) |
||
10561 | listeners[i].apply(this, args); |
||
10562 | } |
||
10563 | |||
10564 | return true; |
||
10565 | }; |
||
10566 | |||
10567 | EventEmitter.prototype.addListener = function(type, listener) { |
||
10568 | var m; |
||
10569 | |||
10570 | if (!isFunction(listener)) |
||
10571 | throw TypeError('listener must be a function'); |
||
10572 | |||
10573 | if (!this._events) |
||
10574 | this._events = {}; |
||
10575 | if (this._events.newListener) |
||
10576 | this.emit('newListener', type, |
||
10577 | isFunction(listener.listener) ? |
||
10578 | listener.listener : listener); |
||
10579 | |||
10580 | if (!this._events[type]) |
||
10581 | this._events[type] = listener; |
||
10582 | else if (isObject(this._events[type])) |
||
10583 | this._events[type].push(listener); |
||
10584 | else |
||
10585 | this._events[type] = [this._events[type], listener]; |
||
10586 | if (isObject(this._events[type]) && !this._events[type].warned) { |
||
10587 | var m; |
||
10588 | if (!isUndefined(this._maxListeners)) { |
||
10589 | m = this._maxListeners; |
||
10590 | } else { |
||
10591 | m = EventEmitter.defaultMaxListeners; |
||
10592 | } |
||
10593 | |||
10594 | if (m && m > 0 && this._events[type].length > m) { |
||
10595 | this._events[type].warned = true; |
||
10596 | console.error('(node) warning: possible EventEmitter memory ' + |
||
10597 | 'leak detected. %d listeners added. ' + |
||
10598 | 'Use emitter.setMaxListeners() to increase limit.', |
||
10599 | this._events[type].length); |
||
10600 | console.trace(); |
||
10601 | } |
||
10602 | } |
||
10603 | |||
10604 | return this; |
||
10605 | }; |
||
10606 | |||
10607 | EventEmitter.prototype.on = EventEmitter.prototype.addListener; |
||
10608 | |||
10609 | EventEmitter.prototype.once = function(type, listener) { |
||
10610 | if (!isFunction(listener)) |
||
10611 | throw TypeError('listener must be a function'); |
||
10612 | |||
10613 | var fired = false; |
||
10614 | |||
10615 | function g() { |
||
10616 | this.removeListener(type, g); |
||
10617 | |||
10618 | if (!fired) { |
||
10619 | fired = true; |
||
10620 | listener.apply(this, arguments); |
||
10621 | } |
||
10622 | } |
||
10623 | |||
10624 | g.listener = listener; |
||
10625 | this.on(type, g); |
||
10626 | |||
10627 | return this; |
||
10628 | }; |
||
10629 | EventEmitter.prototype.removeListener = function(type, listener) { |
||
10630 | var list, position, length, i; |
||
10631 | |||
10632 | if (!isFunction(listener)) |
||
10633 | throw TypeError('listener must be a function'); |
||
10634 | |||
10635 | if (!this._events || !this._events[type]) |
||
10636 | return this; |
||
10637 | |||
10638 | list = this._events[type]; |
||
10639 | length = list.length; |
||
10640 | position = -1; |
||
10641 | |||
10642 | if (list === listener || |
||
10643 | (isFunction(list.listener) && list.listener === listener)) { |
||
10644 | delete this._events[type]; |
||
10645 | if (this._events.removeListener) |
||
10646 | this.emit('removeListener', type, listener); |
||
10647 | |||
10648 | } else if (isObject(list)) { |
||
10649 | for (i = length; i-- > 0;) { |
||
10650 | if (list[i] === listener || |
||
10651 | (list[i].listener && list[i].listener === listener)) { |
||
10652 | position = i; |
||
10653 | break; |
||
10654 | } |
||
10655 | } |
||
10656 | |||
10657 | if (position < 0) |
||
10658 | return this; |
||
10659 | |||
10660 | if (list.length === 1) { |
||
10661 | list.length = 0; |
||
10662 | delete this._events[type]; |
||
10663 | } else { |
||
10664 | list.splice(position, 1); |
||
10665 | } |
||
10666 | |||
10667 | if (this._events.removeListener) |
||
10668 | this.emit('removeListener', type, listener); |
||
10669 | } |
||
10670 | |||
10671 | return this; |
||
10672 | }; |
||
10673 | |||
10674 | EventEmitter.prototype.removeAllListeners = function(type) { |
||
10675 | var key, listeners; |
||
10676 | |||
10677 | if (!this._events) |
||
10678 | return this; |
||
10679 | if (!this._events.removeListener) { |
||
10680 | if (arguments.length === 0) |
||
10681 | this._events = {}; |
||
10682 | else if (this._events[type]) |
||
10683 | delete this._events[type]; |
||
10684 | return this; |
||
10685 | } |
||
10686 | if (arguments.length === 0) { |
||
10687 | for (key in this._events) { |
||
10688 | if (key === 'removeListener') continue; |
||
10689 | this.removeAllListeners(key); |
||
10690 | } |
||
10691 | this.removeAllListeners('removeListener'); |
||
10692 | this._events = {}; |
||
10693 | return this; |
||
10694 | } |
||
10695 | |||
10696 | listeners = this._events[type]; |
||
10697 | |||
10698 | if (isFunction(listeners)) { |
||
10699 | this.removeListener(type, listeners); |
||
10700 | } else { |
||
10701 | while (listeners.length) |
||
10702 | this.removeListener(type, listeners[listeners.length - 1]); |
||
10703 | } |
||
10704 | delete this._events[type]; |
||
10705 | |||
10706 | return this; |
||
10707 | }; |
||
10708 | |||
10709 | EventEmitter.prototype.listeners = function(type) { |
||
10710 | var ret; |
||
10711 | if (!this._events || !this._events[type]) |
||
10712 | ret = []; |
||
10713 | else if (isFunction(this._events[type])) |
||
10714 | ret = [this._events[type]]; |
||
10715 | else |
||
10716 | ret = this._events[type].slice(); |
||
10717 | return ret; |
||
10718 | }; |
||
10719 | |||
10720 | EventEmitter.listenerCount = function(emitter, type) { |
||
10721 | var ret; |
||
10722 | if (!emitter._events || !emitter._events[type]) |
||
10723 | ret = 0; |
||
10724 | else if (isFunction(emitter._events[type])) |
||
10725 | ret = 1; |
||
10726 | else |
||
10727 | ret = emitter._events[type].length; |
||
10728 | return ret; |
||
10729 | }; |
||
10730 | |||
10731 | function isFunction(arg) { |
||
10732 | return typeof arg === 'function'; |
||
10733 | } |
||
10734 | |||
10735 | function isNumber(arg) { |
||
10736 | return typeof arg === 'number'; |
||
10737 | } |
||
10738 | |||
10739 | function isObject(arg) { |
||
10740 | return typeof arg === 'object' && arg !== null; |
||
10741 | } |
||
10742 | |||
10743 | function isUndefined(arg) { |
||
10744 | return arg === void 0; |
||
10745 | } |
||
10746 | |||
10747 | }, |
||
10748 | {}], |
||
10749 | 17:[function(_dereq_,module,exports){ |
||
10750 | if (typeof Object.create === 'function') { |
||
10751 | module.exports = function inherits(ctor, superCtor) { |
||
10752 | ctor.super_ = superCtor |
||
10753 | ctor.prototype = Object.create(superCtor.prototype, { |
||
10754 | constructor: { |
||
10755 | value: ctor, |
||
10756 | enumerable: false, |
||
10757 | writable: true, |
||
10758 | configurable: true |
||
10759 | } |
||
10760 | }); |
||
10761 | }; |
||
10762 | } else { |
||
10763 | module.exports = function inherits(ctor, superCtor) { |
||
10764 | ctor.super_ = superCtor |
||
10765 | var TempCtor = function () {} |
||
10766 | TempCtor.prototype = superCtor.prototype |
||
10767 | ctor.prototype = new TempCtor() |
||
10768 | ctor.prototype.constructor = ctor |
||
10769 | } |
||
10770 | } |
||
10771 | |||
10772 | }, |
||
10773 | {}], |
||
10774 | 18:[function(_dereq_,module,exports){ |
||
10775 | |||
10776 | var process = module.exports = {}; |
||
10777 | |||
10778 | process.nextTick = (function () { |
||
10779 | var canSetImmediate = typeof window !== 'undefined' |
||
10780 | && window.setImmediate; |
||
10781 | var canPost = typeof window !== 'undefined' |
||
10782 | && window.postMessage && window.addEventListener |
||
10783 | ; |
||
10784 | |||
10785 | if (canSetImmediate) { |
||
10786 | return function (f) { return window.setImmediate(f) }; |
||
10787 | } |
||
10788 | |||
10789 | if (canPost) { |
||
10790 | var queue = []; |
||
10791 | window.addEventListener('message', function (ev) { |
||
10792 | var source = ev.source; |
||
10793 | if ((source === window || source === null) && ev.data === 'process-tick') { |
||
10794 | ev.stopPropagation(); |
||
10795 | if (queue.length > 0) { |
||
10796 | var fn = queue.shift(); |
||
10797 | fn(); |
||
10798 | } |
||
10799 | } |
||
10800 | }, true); |
||
10801 | |||
10802 | return function nextTick(fn) { |
||
10803 | queue.push(fn); |
||
10804 | window.postMessage('process-tick', '*'); |
||
10805 | }; |
||
10806 | } |
||
10807 | |||
10808 | return function nextTick(fn) { |
||
10809 | setTimeout(fn, 0); |
||
10810 | }; |
||
10811 | })(); |
||
10812 | |||
10813 | process.title = 'browser'; |
||
10814 | process.browser = true; |
||
10815 | process.env = {}; |
||
10816 | process.argv = []; |
||
10817 | |||
10818 | function noop() {} |
||
10819 | |||
10820 | process.on = noop; |
||
10821 | process.once = noop; |
||
10822 | process.off = noop; |
||
10823 | process.emit = noop; |
||
10824 | |||
10825 | process.binding = function (name) { |
||
10826 | throw new Error('process.binding is not supported'); |
||
10827 | } |
||
10828 | process.cwd = function () { return '/' }; |
||
10829 | process.chdir = function (dir) { |
||
10830 | throw new Error('process.chdir is not supported'); |
||
10831 | }; |
||
10832 | |||
10833 | }, |
||
10834 | {}], |
||
10835 | 19:[function(_dereq_,module,exports){ |
||
10836 | module.exports=_dereq_(14) |
||
10837 | }, |
||
10838 | {}], |
||
10839 | 20:[function(_dereq_,module,exports){ |
||
10840 | module.exports=_dereq_(15) |
||
10841 | }, |
||
10842 | {"./support/isBuffer":19,"/usr/local/lib/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":18,"inherits":17}]},{},[9]) |
||
10843 | (9) |
||
10844 | |||
10845 | }); |
||
10846 | |||
10847 | ace.define("ace/mode/html_worker",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/worker/mirror","ace/mode/html/saxparser"], function(require, exports, module) { |
||
10848 | "use strict"; |
||
10849 | |||
10850 | var oop = require("../lib/oop"); |
||
10851 | var lang = require("../lib/lang"); |
||
10852 | var Mirror = require("../worker/mirror").Mirror; |
||
10853 | var SAXParser = require("./html/saxparser").SAXParser; |
||
10854 | |||
10855 | var errorTypes = { |
||
10856 | "expected-doctype-but-got-start-tag": "info", |
||
10857 | "expected-doctype-but-got-chars": "info", |
||
10858 | "non-html-root": "info" |
||
10859 | } |
||
10860 | |||
10861 | var Worker = exports.Worker = function(sender) { |
||
10862 | Mirror.call(this, sender); |
||
10863 | this.setTimeout(400); |
||
10864 | this.context = null; |
||
10865 | }; |
||
10866 | |||
10867 | oop.inherits(Worker, Mirror); |
||
10868 | |||
10869 | (function() { |
||
10870 | |||
10871 | this.setOptions = function(options) { |
||
10872 | this.context = options.context; |
||
10873 | }; |
||
10874 | |||
10875 | this.onUpdate = function() { |
||
10876 | var value = this.doc.getValue(); |
||
10877 | if (!value) |
||
10878 | return; |
||
10879 | var parser = new SAXParser(); |
||
10880 | var errors = []; |
||
10881 | var noop = function(){}; |
||
10882 | parser.contentHandler = { |
||
10883 | startDocument: noop, |
||
10884 | endDocument: noop, |
||
10885 | startElement: noop, |
||
10886 | endElement: noop, |
||
10887 | characters: noop |
||
10888 | }; |
||
10889 | parser.errorHandler = { |
||
10890 | error: function(message, location, code) { |
||
10891 | errors.push({ |
||
10892 | row: location.line, |
||
10893 | column: location.column, |
||
10894 | text: message, |
||
10895 | type: errorTypes[code] || "error" |
||
10896 | }); |
||
10897 | } |
||
10898 | }; |
||
10899 | if (this.context) |
||
10900 | parser.parseFragment(value, this.context); |
||
10901 | else |
||
10902 | parser.parse(value); |
||
10903 | this.sender.emit("error", errors); |
||
10904 | }; |
||
10905 | |||
10906 | }).call(Worker.prototype); |
||
10907 | |||
10908 | }); |
||
10909 | |||
10910 | ace.define("ace/lib/es5-shim",["require","exports","module"], function(require, exports, module) { |
||
10911 | |||
10912 | function Empty() {} |
||
10913 | |||
10914 | if (!Function.prototype.bind) { |
||
10915 | Function.prototype.bind = function bind(that) { // .length is 1 |
||
10916 | var target = this; |
||
10917 | if (typeof target != "function") { |
||
10918 | throw new TypeError("Function.prototype.bind called on incompatible " + target); |
||
10919 | } |
||
10920 | var args = slice.call(arguments, 1); // for normal call |
||
10921 | var bound = function () { |
||
10922 | |||
10923 | if (this instanceof bound) { |
||
10924 | |||
10925 | var result = target.apply( |
||
10926 | this, |
||
10927 | args.concat(slice.call(arguments)) |
||
10928 | ); |
||
10929 | if (Object(result) === result) { |
||
10930 | return result; |
||
10931 | } |
||
10932 | return this; |
||
10933 | |||
10934 | } else { |
||
10935 | return target.apply( |
||
10936 | that, |
||
10937 | args.concat(slice.call(arguments)) |
||
10938 | ); |
||
10939 | |||
10940 | } |
||
10941 | |||
10942 | }; |
||
10943 | if(target.prototype) { |
||
10944 | Empty.prototype = target.prototype; |
||
10945 | bound.prototype = new Empty(); |
||
10946 | Empty.prototype = null; |
||
10947 | } |
||
10948 | return bound; |
||
10949 | }; |
||
10950 | } |
||
10951 | var call = Function.prototype.call; |
||
10952 | var prototypeOfArray = Array.prototype; |
||
10953 | var prototypeOfObject = Object.prototype; |
||
10954 | var slice = prototypeOfArray.slice; |
||
10955 | var _toString = call.bind(prototypeOfObject.toString); |
||
10956 | var owns = call.bind(prototypeOfObject.hasOwnProperty); |
||
10957 | var defineGetter; |
||
10958 | var defineSetter; |
||
10959 | var lookupGetter; |
||
10960 | var lookupSetter; |
||
10961 | var supportsAccessors; |
||
10962 | if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) { |
||
10963 | defineGetter = call.bind(prototypeOfObject.__defineGetter__); |
||
10964 | defineSetter = call.bind(prototypeOfObject.__defineSetter__); |
||
10965 | lookupGetter = call.bind(prototypeOfObject.__lookupGetter__); |
||
10966 | lookupSetter = call.bind(prototypeOfObject.__lookupSetter__); |
||
10967 | } |
||
10968 | if ([1,2].splice(0).length != 2) { |
||
10969 | if(function() { // test IE < 9 to splice bug - see issue #138 |
||
10970 | function makeArray(l) { |
||
10971 | var a = new Array(l+2); |
||
10972 | a[0] = a[1] = 0; |
||
10973 | return a; |
||
10974 | } |
||
10975 | var array = [], lengthBefore; |
||
10976 | |||
10977 | array.splice.apply(array, makeArray(20)); |
||
10978 | array.splice.apply(array, makeArray(26)); |
||
10979 | |||
10980 | lengthBefore = array.length; //46 |
||
10981 | array.splice(5, 0, "XXX"); // add one element |
||
10982 | |||
10983 | lengthBefore + 1 == array.length |
||
10984 | |||
10985 | if (lengthBefore + 1 == array.length) { |
||
10986 | return true;// has right splice implementation without bugs |
||
10987 | } |
||
10988 | }()) {//IE 6/7 |
||
10989 | var array_splice = Array.prototype.splice; |
||
10990 | Array.prototype.splice = function(start, deleteCount) { |
||
10991 | if (!arguments.length) { |
||
10992 | return []; |
||
10993 | } else { |
||
10994 | return array_splice.apply(this, [ |
||
10995 | start === void 0 ? 0 : start, |
||
10996 | deleteCount === void 0 ? (this.length - start) : deleteCount |
||
10997 | ].concat(slice.call(arguments, 2))) |
||
10998 | } |
||
10999 | }; |
||
11000 | } else {//IE8 |
||
11001 | Array.prototype.splice = function(pos, removeCount){ |
||
11002 | var length = this.length; |
||
11003 | if (pos > 0) { |
||
11004 | if (pos > length) |
||
11005 | pos = length; |
||
11006 | } else if (pos == void 0) { |
||
11007 | pos = 0; |
||
11008 | } else if (pos < 0) { |
||
11009 | pos = Math.max(length + pos, 0); |
||
11010 | } |
||
11011 | |||
11012 | if (!(pos+removeCount < length)) |
||
11013 | removeCount = length - pos; |
||
11014 | |||
11015 | var removed = this.slice(pos, pos+removeCount); |
||
11016 | var insert = slice.call(arguments, 2); |
||
11017 | var add = insert.length; |
||
11018 | if (pos === length) { |
||
11019 | if (add) { |
||
11020 | this.push.apply(this, insert); |
||
11021 | } |
||
11022 | } else { |
||
11023 | var remove = Math.min(removeCount, length - pos); |
||
11024 | var tailOldPos = pos + remove; |
||
11025 | var tailNewPos = tailOldPos + add - remove; |
||
11026 | var tailCount = length - tailOldPos; |
||
11027 | var lengthAfterRemove = length - remove; |
||
11028 | |||
11029 | if (tailNewPos < tailOldPos) { // case A |
||
11030 | for (var i = 0; i < tailCount; ++i) { |
||
11031 | this[tailNewPos+i] = this[tailOldPos+i]; |
||
11032 | } |
||
11033 | } else if (tailNewPos > tailOldPos) { // case B |
||
11034 | for (i = tailCount; i--; ) { |
||
11035 | this[tailNewPos+i] = this[tailOldPos+i]; |
||
11036 | } |
||
11037 | } // else, add == remove (nothing to do) |
||
11038 | |||
11039 | if (add && pos === lengthAfterRemove) { |
||
11040 | this.length = lengthAfterRemove; // truncate array |
||
11041 | this.push.apply(this, insert); |
||
11042 | } else { |
||
11043 | this.length = lengthAfterRemove + add; // reserves space |
||
11044 | for (i = 0; i < add; ++i) { |
||
11045 | this[pos+i] = insert[i]; |
||
11046 | } |
||
11047 | } |
||
11048 | } |
||
11049 | return removed; |
||
11050 | }; |
||
11051 | } |
||
11052 | } |
||
11053 | if (!Array.isArray) { |
||
11054 | Array.isArray = function isArray(obj) { |
||
11055 | return _toString(obj) == "[object Array]"; |
||
11056 | }; |
||
11057 | } |
||
11058 | var boxedString = Object("a"), |
||
11059 | splitString = boxedString[0] != "a" || !(0 in boxedString); |
||
11060 | |||
11061 | if (!Array.prototype.forEach) { |
||
11062 | Array.prototype.forEach = function forEach(fun /*, thisp*/) { |
||
11063 | var object = toObject(this), |
||
11064 | self = splitString && _toString(this) == "[object String]" ? |
||
11065 | this.split("") : |
||
11066 | object, |
||
11067 | thisp = arguments[1], |
||
11068 | i = -1, |
||
11069 | length = self.length >>> 0; |
||
11070 | if (_toString(fun) != "[object Function]") { |
||
11071 | throw new TypeError(); // TODO message |
||
11072 | } |
||
11073 | |||
11074 | while (++i < length) { |
||
11075 | if (i in self) { |
||
11076 | fun.call(thisp, self[i], i, object); |
||
11077 | } |
||
11078 | } |
||
11079 | }; |
||
11080 | } |
||
11081 | if (!Array.prototype.map) { |
||
11082 | Array.prototype.map = function map(fun /*, thisp*/) { |
||
11083 | var object = toObject(this), |
||
11084 | self = splitString && _toString(this) == "[object String]" ? |
||
11085 | this.split("") : |
||
11086 | object, |
||
11087 | length = self.length >>> 0, |
||
11088 | result = Array(length), |
||
11089 | thisp = arguments[1]; |
||
11090 | if (_toString(fun) != "[object Function]") { |
||
11091 | throw new TypeError(fun + " is not a function"); |
||
11092 | } |
||
11093 | |||
11094 | for (var i = 0; i < length; i++) { |
||
11095 | if (i in self) |
||
11096 | result[i] = fun.call(thisp, self[i], i, object); |
||
11097 | } |
||
11098 | return result; |
||
11099 | }; |
||
11100 | } |
||
11101 | if (!Array.prototype.filter) { |
||
11102 | Array.prototype.filter = function filter(fun /*, thisp */) { |
||
11103 | var object = toObject(this), |
||
11104 | self = splitString && _toString(this) == "[object String]" ? |
||
11105 | this.split("") : |
||
11106 | object, |
||
11107 | length = self.length >>> 0, |
||
11108 | result = [], |
||
11109 | value, |
||
11110 | thisp = arguments[1]; |
||
11111 | if (_toString(fun) != "[object Function]") { |
||
11112 | throw new TypeError(fun + " is not a function"); |
||
11113 | } |
||
11114 | |||
11115 | for (var i = 0; i < length; i++) { |
||
11116 | if (i in self) { |
||
11117 | value = self[i]; |
||
11118 | if (fun.call(thisp, value, i, object)) { |
||
11119 | result.push(value); |
||
11120 | } |
||
11121 | } |
||
11122 | } |
||
11123 | return result; |
||
11124 | }; |
||
11125 | } |
||
11126 | if (!Array.prototype.every) { |
||
11127 | Array.prototype.every = function every(fun /*, thisp */) { |
||
11128 | var object = toObject(this), |
||
11129 | self = splitString && _toString(this) == "[object String]" ? |
||
11130 | this.split("") : |
||
11131 | object, |
||
11132 | length = self.length >>> 0, |
||
11133 | thisp = arguments[1]; |
||
11134 | if (_toString(fun) != "[object Function]") { |
||
11135 | throw new TypeError(fun + " is not a function"); |
||
11136 | } |
||
11137 | |||
11138 | for (var i = 0; i < length; i++) { |
||
11139 | if (i in self && !fun.call(thisp, self[i], i, object)) { |
||
11140 | return false; |
||
11141 | } |
||
11142 | } |
||
11143 | return true; |
||
11144 | }; |
||
11145 | } |
||
11146 | if (!Array.prototype.some) { |
||
11147 | Array.prototype.some = function some(fun /*, thisp */) { |
||
11148 | var object = toObject(this), |
||
11149 | self = splitString && _toString(this) == "[object String]" ? |
||
11150 | this.split("") : |
||
11151 | object, |
||
11152 | length = self.length >>> 0, |
||
11153 | thisp = arguments[1]; |
||
11154 | if (_toString(fun) != "[object Function]") { |
||
11155 | throw new TypeError(fun + " is not a function"); |
||
11156 | } |
||
11157 | |||
11158 | for (var i = 0; i < length; i++) { |
||
11159 | if (i in self && fun.call(thisp, self[i], i, object)) { |
||
11160 | return true; |
||
11161 | } |
||
11162 | } |
||
11163 | return false; |
||
11164 | }; |
||
11165 | } |
||
11166 | if (!Array.prototype.reduce) { |
||
11167 | Array.prototype.reduce = function reduce(fun /*, initial*/) { |
||
11168 | var object = toObject(this), |
||
11169 | self = splitString && _toString(this) == "[object String]" ? |
||
11170 | this.split("") : |
||
11171 | object, |
||
11172 | length = self.length >>> 0; |
||
11173 | if (_toString(fun) != "[object Function]") { |
||
11174 | throw new TypeError(fun + " is not a function"); |
||
11175 | } |
||
11176 | if (!length && arguments.length == 1) { |
||
11177 | throw new TypeError("reduce of empty array with no initial value"); |
||
11178 | } |
||
11179 | |||
11180 | var i = 0; |
||
11181 | var result; |
||
11182 | if (arguments.length >= 2) { |
||
11183 | result = arguments[1]; |
||
11184 | } else { |
||
11185 | do { |
||
11186 | if (i in self) { |
||
11187 | result = self[i++]; |
||
11188 | break; |
||
11189 | } |
||
11190 | if (++i >= length) { |
||
11191 | throw new TypeError("reduce of empty array with no initial value"); |
||
11192 | } |
||
11193 | } while (true); |
||
11194 | } |
||
11195 | |||
11196 | for (; i < length; i++) { |
||
11197 | if (i in self) { |
||
11198 | result = fun.call(void 0, result, self[i], i, object); |
||
11199 | } |
||
11200 | } |
||
11201 | |||
11202 | return result; |
||
11203 | }; |
||
11204 | } |
||
11205 | if (!Array.prototype.reduceRight) { |
||
11206 | Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) { |
||
11207 | var object = toObject(this), |
||
11208 | self = splitString && _toString(this) == "[object String]" ? |
||
11209 | this.split("") : |
||
11210 | object, |
||
11211 | length = self.length >>> 0; |
||
11212 | if (_toString(fun) != "[object Function]") { |
||
11213 | throw new TypeError(fun + " is not a function"); |
||
11214 | } |
||
11215 | if (!length && arguments.length == 1) { |
||
11216 | throw new TypeError("reduceRight of empty array with no initial value"); |
||
11217 | } |
||
11218 | |||
11219 | var result, i = length - 1; |
||
11220 | if (arguments.length >= 2) { |
||
11221 | result = arguments[1]; |
||
11222 | } else { |
||
11223 | do { |
||
11224 | if (i in self) { |
||
11225 | result = self[i--]; |
||
11226 | break; |
||
11227 | } |
||
11228 | if (--i < 0) { |
||
11229 | throw new TypeError("reduceRight of empty array with no initial value"); |
||
11230 | } |
||
11231 | } while (true); |
||
11232 | } |
||
11233 | |||
11234 | do { |
||
11235 | if (i in this) { |
||
11236 | result = fun.call(void 0, result, self[i], i, object); |
||
11237 | } |
||
11238 | } while (i--); |
||
11239 | |||
11240 | return result; |
||
11241 | }; |
||
11242 | } |
||
11243 | if (!Array.prototype.indexOf || ([0, 1].indexOf(1, 2) != -1)) { |
||
11244 | Array.prototype.indexOf = function indexOf(sought /*, fromIndex */ ) { |
||
11245 | var self = splitString && _toString(this) == "[object String]" ? |
||
11246 | this.split("") : |
||
11247 | toObject(this), |
||
11248 | length = self.length >>> 0; |
||
11249 | |||
11250 | if (!length) { |
||
11251 | return -1; |
||
11252 | } |
||
11253 | |||
11254 | var i = 0; |
||
11255 | if (arguments.length > 1) { |
||
11256 | i = toInteger(arguments[1]); |
||
11257 | } |
||
11258 | i = i >= 0 ? i : Math.max(0, length + i); |
||
11259 | for (; i < length; i++) { |
||
11260 | if (i in self && self[i] === sought) { |
||
11261 | return i; |
||
11262 | } |
||
11263 | } |
||
11264 | return -1; |
||
11265 | }; |
||
11266 | } |
||
11267 | if (!Array.prototype.lastIndexOf || ([0, 1].lastIndexOf(0, -3) != -1)) { |
||
11268 | Array.prototype.lastIndexOf = function lastIndexOf(sought /*, fromIndex */) { |
||
11269 | var self = splitString && _toString(this) == "[object String]" ? |
||
11270 | this.split("") : |
||
11271 | toObject(this), |
||
11272 | length = self.length >>> 0; |
||
11273 | |||
11274 | if (!length) { |
||
11275 | return -1; |
||
11276 | } |
||
11277 | var i = length - 1; |
||
11278 | if (arguments.length > 1) { |
||
11279 | i = Math.min(i, toInteger(arguments[1])); |
||
11280 | } |
||
11281 | i = i >= 0 ? i : length - Math.abs(i); |
||
11282 | for (; i >= 0; i--) { |
||
11283 | if (i in self && sought === self[i]) { |
||
11284 | return i; |
||
11285 | } |
||
11286 | } |
||
11287 | return -1; |
||
11288 | }; |
||
11289 | } |
||
11290 | if (!Object.getPrototypeOf) { |
||
11291 | Object.getPrototypeOf = function getPrototypeOf(object) { |
||
11292 | return object.__proto__ || ( |
||
11293 | object.constructor ? |
||
11294 | object.constructor.prototype : |
||
11295 | prototypeOfObject |
||
11296 | ); |
||
11297 | }; |
||
11298 | } |
||
11299 | if (!Object.getOwnPropertyDescriptor) { |
||
11300 | var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a " + |
||
11301 | "non-object: "; |
||
11302 | Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) { |
||
11303 | if ((typeof object != "object" && typeof object != "function") || object === null) |
||
11304 | throw new TypeError(ERR_NON_OBJECT + object); |
||
11305 | if (!owns(object, property)) |
||
11306 | return; |
||
11307 | |||
11308 | var descriptor, getter, setter; |
||
11309 | descriptor = { enumerable: true, configurable: true }; |
||
11310 | if (supportsAccessors) { |
||
11311 | var prototype = object.__proto__; |
||
11312 | object.__proto__ = prototypeOfObject; |
||
11313 | |||
11314 | var getter = lookupGetter(object, property); |
||
11315 | var setter = lookupSetter(object, property); |
||
11316 | object.__proto__ = prototype; |
||
11317 | |||
11318 | if (getter || setter) { |
||
11319 | if (getter) descriptor.get = getter; |
||
11320 | if (setter) descriptor.set = setter; |
||
11321 | return descriptor; |
||
11322 | } |
||
11323 | } |
||
11324 | descriptor.value = object[property]; |
||
11325 | return descriptor; |
||
11326 | }; |
||
11327 | } |
||
11328 | if (!Object.getOwnPropertyNames) { |
||
11329 | Object.getOwnPropertyNames = function getOwnPropertyNames(object) { |
||
11330 | return Object.keys(object); |
||
11331 | }; |
||
11332 | } |
||
11333 | if (!Object.create) { |
||
11334 | var createEmpty; |
||
11335 | if (Object.prototype.__proto__ === null) { |
||
11336 | createEmpty = function () { |
||
11337 | return { "__proto__": null }; |
||
11338 | }; |
||
11339 | } else { |
||
11340 | createEmpty = function () { |
||
11341 | var empty = {}; |
||
11342 | for (var i in empty) |
||
11343 | empty[i] = null; |
||
11344 | empty.constructor = |
||
11345 | empty.hasOwnProperty = |
||
11346 | empty.propertyIsEnumerable = |
||
11347 | empty.isPrototypeOf = |
||
11348 | empty.toLocaleString = |
||
11349 | empty.toString = |
||
11350 | empty.valueOf = |
||
11351 | empty.__proto__ = null; |
||
11352 | return empty; |
||
11353 | } |
||
11354 | } |
||
11355 | |||
11356 | Object.create = function create(prototype, properties) { |
||
11357 | var object; |
||
11358 | if (prototype === null) { |
||
11359 | object = createEmpty(); |
||
11360 | } else { |
||
11361 | if (typeof prototype != "object") |
||
11362 | throw new TypeError("typeof prototype["+(typeof prototype)+"] != 'object'"); |
||
11363 | var Type = function () {}; |
||
11364 | Type.prototype = prototype; |
||
11365 | object = new Type(); |
||
11366 | object.__proto__ = prototype; |
||
11367 | } |
||
11368 | if (properties !== void 0) |
||
11369 | Object.defineProperties(object, properties); |
||
11370 | return object; |
||
11371 | }; |
||
11372 | } |
||
11373 | |||
11374 | function doesDefinePropertyWork(object) { |
||
11375 | try { |
||
11376 | Object.defineProperty(object, "sentinel", {}); |
||
11377 | return "sentinel" in object; |
||
11378 | } catch (exception) { |
||
11379 | } |
||
11380 | } |
||
11381 | if (Object.defineProperty) { |
||
11382 | var definePropertyWorksOnObject = doesDefinePropertyWork({}); |
||
11383 | var definePropertyWorksOnDom = typeof document == "undefined" || |
||
11384 | doesDefinePropertyWork(document.createElement("div")); |
||
11385 | if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) { |
||
11386 | var definePropertyFallback = Object.defineProperty; |
||
11387 | } |
||
11388 | } |
||
11389 | |||
11390 | if (!Object.defineProperty || definePropertyFallback) { |
||
11391 | var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: "; |
||
11392 | var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: " |
||
11393 | var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " + |
||
11394 | "on this javascript engine"; |
||
11395 | |||
11396 | Object.defineProperty = function defineProperty(object, property, descriptor) { |
||
11397 | if ((typeof object != "object" && typeof object != "function") || object === null) |
||
11398 | throw new TypeError(ERR_NON_OBJECT_TARGET + object); |
||
11399 | if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null) |
||
11400 | throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor); |
||
11401 | if (definePropertyFallback) { |
||
11402 | try { |
||
11403 | return definePropertyFallback.call(Object, object, property, descriptor); |
||
11404 | } catch (exception) { |
||
11405 | } |
||
11406 | } |
||
11407 | if (owns(descriptor, "value")) { |
||
11408 | |||
11409 | if (supportsAccessors && (lookupGetter(object, property) || |
||
11410 | lookupSetter(object, property))) |
||
11411 | { |
||
11412 | var prototype = object.__proto__; |
||
11413 | object.__proto__ = prototypeOfObject; |
||
11414 | delete object[property]; |
||
11415 | object[property] = descriptor.value; |
||
11416 | object.__proto__ = prototype; |
||
11417 | } else { |
||
11418 | object[property] = descriptor.value; |
||
11419 | } |
||
11420 | } else { |
||
11421 | if (!supportsAccessors) |
||
11422 | throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED); |
||
11423 | if (owns(descriptor, "get")) |
||
11424 | defineGetter(object, property, descriptor.get); |
||
11425 | if (owns(descriptor, "set")) |
||
11426 | defineSetter(object, property, descriptor.set); |
||
11427 | } |
||
11428 | |||
11429 | return object; |
||
11430 | }; |
||
11431 | } |
||
11432 | if (!Object.defineProperties) { |
||
11433 | Object.defineProperties = function defineProperties(object, properties) { |
||
11434 | for (var property in properties) { |
||
11435 | if (owns(properties, property)) |
||
11436 | Object.defineProperty(object, property, properties[property]); |
||
11437 | } |
||
11438 | return object; |
||
11439 | }; |
||
11440 | } |
||
11441 | if (!Object.seal) { |
||
11442 | Object.seal = function seal(object) { |
||
11443 | return object; |
||
11444 | }; |
||
11445 | } |
||
11446 | if (!Object.freeze) { |
||
11447 | Object.freeze = function freeze(object) { |
||
11448 | return object; |
||
11449 | }; |
||
11450 | } |
||
11451 | try { |
||
11452 | Object.freeze(function () {}); |
||
11453 | } catch (exception) { |
||
11454 | Object.freeze = (function freeze(freezeObject) { |
||
11455 | return function freeze(object) { |
||
11456 | if (typeof object == "function") { |
||
11457 | return object; |
||
11458 | } else { |
||
11459 | return freezeObject(object); |
||
11460 | } |
||
11461 | }; |
||
11462 | })(Object.freeze); |
||
11463 | } |
||
11464 | if (!Object.preventExtensions) { |
||
11465 | Object.preventExtensions = function preventExtensions(object) { |
||
11466 | return object; |
||
11467 | }; |
||
11468 | } |
||
11469 | if (!Object.isSealed) { |
||
11470 | Object.isSealed = function isSealed(object) { |
||
11471 | return false; |
||
11472 | }; |
||
11473 | } |
||
11474 | if (!Object.isFrozen) { |
||
11475 | Object.isFrozen = function isFrozen(object) { |
||
11476 | return false; |
||
11477 | }; |
||
11478 | } |
||
11479 | if (!Object.isExtensible) { |
||
11480 | Object.isExtensible = function isExtensible(object) { |
||
11481 | if (Object(object) === object) { |
||
11482 | throw new TypeError(); // TODO message |
||
11483 | } |
||
11484 | var name = ''; |
||
11485 | while (owns(object, name)) { |
||
11486 | name += '?'; |
||
11487 | } |
||
11488 | object[name] = true; |
||
11489 | var returnValue = owns(object, name); |
||
11490 | delete object[name]; |
||
11491 | return returnValue; |
||
11492 | }; |
||
11493 | } |
||
11494 | if (!Object.keys) { |
||
11495 | var hasDontEnumBug = true, |
||
11496 | dontEnums = [ |
||
11497 | "toString", |
||
11498 | "toLocaleString", |
||
11499 | "valueOf", |
||
11500 | "hasOwnProperty", |
||
11501 | "isPrototypeOf", |
||
11502 | "propertyIsEnumerable", |
||
11503 | "constructor" |
||
11504 | ], |
||
11505 | dontEnumsLength = dontEnums.length; |
||
11506 | |||
11507 | for (var key in {"toString": null}) { |
||
11508 | hasDontEnumBug = false; |
||
11509 | } |
||
11510 | |||
11511 | Object.keys = function keys(object) { |
||
11512 | |||
11513 | if ( |
||
11514 | (typeof object != "object" && typeof object != "function") || |
||
11515 | object === null |
||
11516 | ) { |
||
11517 | throw new TypeError("Object.keys called on a non-object"); |
||
11518 | } |
||
11519 | |||
11520 | var keys = []; |
||
11521 | for (var name in object) { |
||
11522 | if (owns(object, name)) { |
||
11523 | keys.push(name); |
||
11524 | } |
||
11525 | } |
||
11526 | |||
11527 | if (hasDontEnumBug) { |
||
11528 | for (var i = 0, ii = dontEnumsLength; i < ii; i++) { |
||
11529 | var dontEnum = dontEnums[i]; |
||
11530 | if (owns(object, dontEnum)) { |
||
11531 | keys.push(dontEnum); |
||
11532 | } |
||
11533 | } |
||
11534 | } |
||
11535 | return keys; |
||
11536 | }; |
||
11537 | |||
11538 | } |
||
11539 | if (!Date.now) { |
||
11540 | Date.now = function now() { |
||
11541 | return new Date().getTime(); |
||
11542 | }; |
||
11543 | } |
||
11544 | var ws = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" + |
||
11545 | "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" + |
||
11546 | "\u2029\uFEFF"; |
||
11547 | if (!String.prototype.trim || ws.trim()) { |
||
11548 | ws = "[" + ws + "]"; |
||
11549 | var trimBeginRegexp = new RegExp("^" + ws + ws + "*"), |
||
11550 | trimEndRegexp = new RegExp(ws + ws + "*$"); |
||
11551 | String.prototype.trim = function trim() { |
||
11552 | return String(this).replace(trimBeginRegexp, "").replace(trimEndRegexp, ""); |
||
11553 | }; |
||
11554 | } |
||
11555 | |||
11556 | function toInteger(n) { |
||
11557 | n = +n; |
||
11558 | if (n !== n) { // isNaN |
||
11559 | n = 0; |
||
11560 | } else if (n !== 0 && n !== (1/0) && n !== -(1/0)) { |
||
11561 | n = (n > 0 || -1) * Math.floor(Math.abs(n)); |
||
11562 | } |
||
11563 | return n; |
||
11564 | } |
||
11565 | |||
11566 | function isPrimitive(input) { |
||
11567 | var type = typeof input; |
||
11568 | return ( |
||
11569 | input === null || |
||
11570 | type === "undefined" || |
||
11571 | type === "boolean" || |
||
11572 | type === "number" || |
||
11573 | type === "string" |
||
11574 | ); |
||
11575 | } |
||
11576 | |||
11577 | function toPrimitive(input) { |
||
11578 | var val, valueOf, toString; |
||
11579 | if (isPrimitive(input)) { |
||
11580 | return input; |
||
11581 | } |
||
11582 | valueOf = input.valueOf; |
||
11583 | if (typeof valueOf === "function") { |
||
11584 | val = valueOf.call(input); |
||
11585 | if (isPrimitive(val)) { |
||
11586 | return val; |
||
11587 | } |
||
11588 | } |
||
11589 | toString = input.toString; |
||
11590 | if (typeof toString === "function") { |
||
11591 | val = toString.call(input); |
||
11592 | if (isPrimitive(val)) { |
||
11593 | return val; |
||
11594 | } |
||
11595 | } |
||
11596 | throw new TypeError(); |
||
11597 | } |
||
11598 | var toObject = function (o) { |
||
11599 | if (o == null) { // this matches both null and undefined |
||
11600 | throw new TypeError("can't convert "+o+" to object"); |
||
11601 | } |
||
11602 | return Object(o); |
||
11603 | }; |
||
11604 | |||
11605 | }); |