1 |
|
2 |
|
3 |
|
4 |
|
5 | 'use strict';
|
6 |
|
7 | Object.defineProperty(exports, '__esModule', { value: true });
|
8 |
|
9 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
10 |
|
11 | var path = require('path');
|
12 | var path__default = _interopDefault(path);
|
13 | var Evk = _interopDefault(require('eslint-visitor-keys'));
|
14 | var sortedLastIndex = _interopDefault(require('lodash/sortedLastIndex'));
|
15 | var assert = _interopDefault(require('assert'));
|
16 | var last = _interopDefault(require('lodash/last'));
|
17 | var findLastIndex = _interopDefault(require('lodash/findLastIndex'));
|
18 | var debugFactory = _interopDefault(require('debug'));
|
19 | var sortedIndexBy = _interopDefault(require('lodash/sortedIndexBy'));
|
20 | var sortedLastIndexBy = _interopDefault(require('lodash/sortedLastIndexBy'));
|
21 | var first = _interopDefault(require('lodash/first'));
|
22 | var escope = _interopDefault(require('eslint-scope'));
|
23 | var Module = _interopDefault(require('module'));
|
24 | var EventEmitter = _interopDefault(require('events'));
|
25 | var esquery = _interopDefault(require('esquery'));
|
26 | var union = _interopDefault(require('lodash/union'));
|
27 | var intersection = _interopDefault(require('lodash/intersection'));
|
28 | var memoize = _interopDefault(require('lodash/memoize'));
|
29 |
|
30 | function isAcornStyleParseError(x) {
|
31 | return (typeof x.message === "string" &&
|
32 | typeof x.pos === "number" &&
|
33 | typeof x.loc === "object" &&
|
34 | x.loc !== null &&
|
35 | typeof x.loc.line === "number" &&
|
36 | typeof x.loc.column === "number");
|
37 | }
|
38 | class ParseError extends SyntaxError {
|
39 | static fromCode(code, offset, line, column) {
|
40 | return new ParseError(code, code, offset, line, column);
|
41 | }
|
42 | static normalize(x) {
|
43 | if (ParseError.isParseError(x)) {
|
44 | return x;
|
45 | }
|
46 | if (isAcornStyleParseError(x)) {
|
47 | return new ParseError(x.message, undefined, x.pos, x.loc.line, x.loc.column);
|
48 | }
|
49 | return null;
|
50 | }
|
51 | constructor(message, code, offset, line, column) {
|
52 | super(message);
|
53 | this.code = code;
|
54 | this.index = offset;
|
55 | this.lineNumber = line;
|
56 | this.column = column;
|
57 | }
|
58 | static isParseError(x) {
|
59 | return (x instanceof ParseError ||
|
60 | (typeof x.message === "string" &&
|
61 | typeof x.index === "number" &&
|
62 | typeof x.lineNumber === "number" &&
|
63 | typeof x.column === "number"));
|
64 | }
|
65 | }
|
66 |
|
67 | const NS = Object.freeze({
|
68 | HTML: "http://www.w3.org/1999/xhtml",
|
69 | MathML: "http://www.w3.org/1998/Math/MathML",
|
70 | SVG: "http://www.w3.org/2000/svg",
|
71 | XLink: "http://www.w3.org/1999/xlink",
|
72 | XML: "http://www.w3.org/XML/1998/namespace",
|
73 | XMLNS: "http://www.w3.org/2000/xmlns/",
|
74 | });
|
75 |
|
76 | const KEYS = Evk.unionWith({
|
77 | VAttribute: ["key", "value"],
|
78 | VDirectiveKey: ["name", "argument", "modifiers"],
|
79 | VDocumentFragment: ["children"],
|
80 | VElement: ["startTag", "children", "endTag"],
|
81 | VEndTag: [],
|
82 | VExpressionContainer: ["expression"],
|
83 | VFilter: ["callee", "arguments"],
|
84 | VFilterSequenceExpression: ["expression", "filters"],
|
85 | VForExpression: ["left", "right"],
|
86 | VIdentifier: [],
|
87 | VLiteral: [],
|
88 | VOnExpression: ["body"],
|
89 | VSlotScopeExpression: ["params"],
|
90 | VStartTag: ["attributes"],
|
91 | VText: [],
|
92 | });
|
93 | function fallbackKeysFilter(key) {
|
94 | let value = null;
|
95 | return (key !== "comments" &&
|
96 | key !== "leadingComments" &&
|
97 | key !== "loc" &&
|
98 | key !== "parent" &&
|
99 | key !== "range" &&
|
100 | key !== "tokens" &&
|
101 | key !== "trailingComments" &&
|
102 | (value = this[key]) !== null &&
|
103 | typeof value === "object" &&
|
104 | (typeof value.type === "string" || Array.isArray(value)));
|
105 | }
|
106 | function getFallbackKeys(node) {
|
107 | return Object.keys(node).filter(fallbackKeysFilter, node);
|
108 | }
|
109 | function isNode(x) {
|
110 | return x !== null && typeof x === "object" && typeof x.type === "string";
|
111 | }
|
112 | function traverse(node, parent, visitor) {
|
113 | let i = 0;
|
114 | let j = 0;
|
115 | visitor.enterNode(node, parent);
|
116 | const keys = (visitor.visitorKeys || KEYS)[node.type] || getFallbackKeys(node);
|
117 | for (i = 0; i < keys.length; ++i) {
|
118 | const child = node[keys[i]];
|
119 | if (Array.isArray(child)) {
|
120 | for (j = 0; j < child.length; ++j) {
|
121 | if (isNode(child[j])) {
|
122 | traverse(child[j], node, visitor);
|
123 | }
|
124 | }
|
125 | }
|
126 | else if (isNode(child)) {
|
127 | traverse(child, node, visitor);
|
128 | }
|
129 | }
|
130 | visitor.leaveNode(node, parent);
|
131 | }
|
132 | function traverseNodes(node, visitor) {
|
133 | traverse(node, null, visitor);
|
134 | }
|
135 |
|
136 |
|
137 |
|
138 | var index = Object.freeze({
|
139 | __proto__: null,
|
140 | ParseError: ParseError,
|
141 | NS: NS,
|
142 | traverseNodes: traverseNodes,
|
143 | getFallbackKeys: getFallbackKeys
|
144 | });
|
145 |
|
146 | class LocationCalculator {
|
147 | constructor(gapOffsets, ltOffsets, baseOffset) {
|
148 | this.gapOffsets = gapOffsets;
|
149 | this.ltOffsets = ltOffsets;
|
150 | this.baseOffset = baseOffset || 0;
|
151 | this.baseIndexOfGap =
|
152 | this.baseOffset === 0
|
153 | ? 0
|
154 | : sortedLastIndex(gapOffsets, this.baseOffset);
|
155 | }
|
156 | getSubCalculatorAfter(offset) {
|
157 | return new LocationCalculator(this.gapOffsets, this.ltOffsets, this.baseOffset + offset);
|
158 | }
|
159 | _getLocation(offset) {
|
160 | const line = sortedLastIndex(this.ltOffsets, offset) + 1;
|
161 | const column = offset - (line === 1 ? 0 : this.ltOffsets[line - 2]);
|
162 | return { line, column };
|
163 | }
|
164 | _getGap(index) {
|
165 | const offsets = this.gapOffsets;
|
166 | let g0 = sortedLastIndex(offsets, index + this.baseOffset);
|
167 | let pos = index + this.baseOffset + g0 - this.baseIndexOfGap;
|
168 | while (g0 < offsets.length && offsets[g0] <= pos) {
|
169 | g0 += 1;
|
170 | pos += 1;
|
171 | }
|
172 | return g0 - this.baseIndexOfGap;
|
173 | }
|
174 | getLocation(index) {
|
175 | return this._getLocation(this.baseOffset + index);
|
176 | }
|
177 | getOffsetWithGap(index) {
|
178 | return this.baseOffset + index + this._getGap(index);
|
179 | }
|
180 | fixLocation(node) {
|
181 | const range = node.range;
|
182 | const loc = node.loc;
|
183 | const gap0 = this._getGap(range[0]);
|
184 | const gap1 = this._getGap(range[1]);
|
185 | const d0 = this.baseOffset + Math.max(0, gap0);
|
186 | const d1 = this.baseOffset + Math.max(0, gap1);
|
187 | if (d0 !== 0) {
|
188 | range[0] += d0;
|
189 | if (node.start != null) {
|
190 | node.start += d0;
|
191 | }
|
192 | loc.start = this._getLocation(range[0]);
|
193 | }
|
194 | if (d1 !== 0) {
|
195 | range[1] += d1;
|
196 | if (node.end != null) {
|
197 | node.end += d0;
|
198 | }
|
199 | loc.end = this._getLocation(range[1]);
|
200 | }
|
201 | return node;
|
202 | }
|
203 | fixErrorLocation(error) {
|
204 | const gap = this._getGap(error.index);
|
205 | const diff = this.baseOffset + Math.max(0, gap);
|
206 | error.index += diff;
|
207 | const loc = this._getLocation(error.index);
|
208 | error.lineNumber = loc.line;
|
209 | error.column = loc.column;
|
210 | }
|
211 | }
|
212 |
|
213 | const debug = debugFactory("vue-eslint-parser");
|
214 |
|
215 | function isUnique(reference, index, references) {
|
216 | return (index === 0 || reference.identifier !== references[index - 1].identifier);
|
217 | }
|
218 | function hasDefinition(variable) {
|
219 | return variable.defs.length >= 1;
|
220 | }
|
221 | function transformReference(reference) {
|
222 | const ret = {
|
223 | id: reference.identifier,
|
224 | mode: reference.isReadOnly()
|
225 | ? "r"
|
226 | : reference.isWriteOnly()
|
227 | ? "w"
|
228 | : "rw",
|
229 | variable: null,
|
230 | };
|
231 | Object.defineProperty(ret, "variable", { enumerable: false });
|
232 | return ret;
|
233 | }
|
234 | function transformVariable(variable) {
|
235 | const ret = {
|
236 | id: variable.defs[0].name,
|
237 | kind: variable.scope.type === "for" ? "v-for" : "scope",
|
238 | references: [],
|
239 | };
|
240 | Object.defineProperty(ret, "references", { enumerable: false });
|
241 | return ret;
|
242 | }
|
243 | function getForScope(scope) {
|
244 | const child = scope.childScopes[0];
|
245 | return child.block === scope.block ? child.childScopes[0] : child;
|
246 | }
|
247 | function analyze(ast, parserOptions) {
|
248 | const ecmaVersion = parserOptions.ecmaVersion || 2017;
|
249 | const ecmaFeatures = parserOptions.ecmaFeatures || {};
|
250 | const sourceType = parserOptions.sourceType || "script";
|
251 | const result = escope.analyze(ast, {
|
252 | ignoreEval: true,
|
253 | nodejsScope: false,
|
254 | impliedStrict: ecmaFeatures.impliedStrict,
|
255 | ecmaVersion,
|
256 | sourceType,
|
257 | fallback: getFallbackKeys,
|
258 | });
|
259 | return result.globalScope;
|
260 | }
|
261 | function analyzeExternalReferences(ast, parserOptions) {
|
262 | const scope = analyze(ast, parserOptions);
|
263 | return scope.through.filter(isUnique).map(transformReference);
|
264 | }
|
265 | function analyzeVariablesAndExternalReferences(ast, parserOptions) {
|
266 | const scope = analyze(ast, parserOptions);
|
267 | return {
|
268 | variables: getForScope(scope)
|
269 | .variables.filter(hasDefinition)
|
270 | .map(transformVariable),
|
271 | references: scope.through.filter(isUnique).map(transformReference),
|
272 | };
|
273 | }
|
274 |
|
275 | const createRequire = Module.createRequire ||
|
276 | Module.createRequireFromPath ||
|
277 | (filename => {
|
278 | const mod = new Module(filename);
|
279 | mod.filename = filename;
|
280 | mod.paths = Module._nodeModulePaths(path__default.dirname(filename));
|
281 | mod._compile("module.exports = require;", filename);
|
282 | return mod.exports;
|
283 | });
|
284 | let espreeCache = null;
|
285 | function isLinterPath(p) {
|
286 | return (p.includes(`eslint${path__default.sep}lib${path__default.sep}linter${path__default.sep}linter.js`) ||
|
287 | p.includes(`eslint${path__default.sep}lib${path__default.sep}linter.js`));
|
288 | }
|
289 | function getEspree() {
|
290 | if (!espreeCache) {
|
291 | const linterPath = Object.keys(require.cache).find(isLinterPath);
|
292 | if (linterPath) {
|
293 | try {
|
294 | espreeCache = createRequire(linterPath)("espree");
|
295 | }
|
296 | catch (_a) {
|
297 | }
|
298 | }
|
299 | if (!espreeCache) {
|
300 | espreeCache = require("espree");
|
301 | }
|
302 | }
|
303 | return espreeCache;
|
304 | }
|
305 |
|
306 | const ALIAS_PARENS = /^(\s*)\(([\s\S]+)\)(\s*(?:in|of)\b[\s\S]+)$/u;
|
307 | const DUMMY_PARENT = {};
|
308 | const IS_FUNCTION_EXPRESSION = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^function\s*\(/u;
|
309 | const IS_SIMPLE_PATH = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?'\]|\["[^"]*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/u;
|
310 | function postprocess(result, locationCalculator) {
|
311 | const traversed = new Set();
|
312 | traverseNodes(result.ast, {
|
313 | visitorKeys: result.visitorKeys,
|
314 | enterNode(node, parent) {
|
315 | if (!traversed.has(node)) {
|
316 | traversed.add(node);
|
317 | node.parent = parent;
|
318 | if (!traversed.has(node.range)) {
|
319 | traversed.add(node.range);
|
320 | locationCalculator.fixLocation(node);
|
321 | }
|
322 | }
|
323 | },
|
324 | leaveNode() {
|
325 | },
|
326 | });
|
327 | for (const token of result.ast.tokens || []) {
|
328 | locationCalculator.fixLocation(token);
|
329 | }
|
330 | for (const comment of result.ast.comments || []) {
|
331 | locationCalculator.fixLocation(comment);
|
332 | }
|
333 | }
|
334 | function replaceAliasParens(code) {
|
335 | const match = ALIAS_PARENS.exec(code);
|
336 | if (match != null) {
|
337 | return `${match[1]}[${match[2]}]${match[3]}`;
|
338 | }
|
339 | return code;
|
340 | }
|
341 | function normalizeLeft(left, replaced) {
|
342 | if (left.type !== "VariableDeclaration") {
|
343 | throw new Error("unreachable");
|
344 | }
|
345 | const id = left.declarations[0].id;
|
346 | if (replaced) {
|
347 | return id.elements;
|
348 | }
|
349 | return [id];
|
350 | }
|
351 | function getCommaTokenBeforeNode(tokens, node) {
|
352 | let tokenIndex = sortedIndexBy(tokens, { range: node.range }, t => t.range[0]);
|
353 | while (tokenIndex >= 0) {
|
354 | const token = tokens[tokenIndex];
|
355 | if (token.type === "Punctuator" && token.value === ",") {
|
356 | return token;
|
357 | }
|
358 | tokenIndex -= 1;
|
359 | }
|
360 | return null;
|
361 | }
|
362 | function throwEmptyError(locationCalculator, expected) {
|
363 | const loc = locationCalculator.getLocation(0);
|
364 | const err = new ParseError(`Expected to be ${expected}, but got empty.`, undefined, 0, loc.line, loc.column);
|
365 | locationCalculator.fixErrorLocation(err);
|
366 | throw err;
|
367 | }
|
368 | function throwUnexpectedTokenError(name, token) {
|
369 | const err = new ParseError(`Unexpected token '${name}'.`, undefined, token.range[0], token.loc.start.line, token.loc.start.column);
|
370 | throw err;
|
371 | }
|
372 | function throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator) {
|
373 | if (ParseError.isParseError(err)) {
|
374 | const endOffset = locationCalculator.getOffsetWithGap(code.length);
|
375 | if (err.index >= endOffset) {
|
376 | err.message = "Unexpected end of expression.";
|
377 | }
|
378 | }
|
379 | throw err;
|
380 | }
|
381 | function parseScriptFragment(code, locationCalculator, parserOptions) {
|
382 | try {
|
383 | const result = parseScript(code, parserOptions);
|
384 | postprocess(result, locationCalculator);
|
385 | return result;
|
386 | }
|
387 | catch (err) {
|
388 | const perr = ParseError.normalize(err);
|
389 | if (perr) {
|
390 | locationCalculator.fixErrorLocation(perr);
|
391 | throw perr;
|
392 | }
|
393 | throw err;
|
394 | }
|
395 | }
|
396 | const validDivisionCharRE = /[\w).+\-_$\]]/u;
|
397 | function splitFilters(exp) {
|
398 | const result = [];
|
399 | let inSingle = false;
|
400 | let inDouble = false;
|
401 | let inTemplateString = false;
|
402 | let inRegex = false;
|
403 | let curly = 0;
|
404 | let square = 0;
|
405 | let paren = 0;
|
406 | let lastFilterIndex = 0;
|
407 | let c = 0;
|
408 | let prev = 0;
|
409 | for (let i = 0; i < exp.length; i++) {
|
410 | prev = c;
|
411 | c = exp.charCodeAt(i);
|
412 | if (inSingle) {
|
413 | if (c === 0x27 && prev !== 0x5c) {
|
414 | inSingle = false;
|
415 | }
|
416 | }
|
417 | else if (inDouble) {
|
418 | if (c === 0x22 && prev !== 0x5c) {
|
419 | inDouble = false;
|
420 | }
|
421 | }
|
422 | else if (inTemplateString) {
|
423 | if (c === 0x60 && prev !== 0x5c) {
|
424 | inTemplateString = false;
|
425 | }
|
426 | }
|
427 | else if (inRegex) {
|
428 | if (c === 0x2f && prev !== 0x5c) {
|
429 | inRegex = false;
|
430 | }
|
431 | }
|
432 | else if (c === 0x7c &&
|
433 | exp.charCodeAt(i + 1) !== 0x7c &&
|
434 | exp.charCodeAt(i - 1) !== 0x7c &&
|
435 | !curly &&
|
436 | !square &&
|
437 | !paren) {
|
438 | result.push(exp.slice(lastFilterIndex, i));
|
439 | lastFilterIndex = i + 1;
|
440 | }
|
441 | else {
|
442 | switch (c) {
|
443 | case 0x22:
|
444 | inDouble = true;
|
445 | break;
|
446 | case 0x27:
|
447 | inSingle = true;
|
448 | break;
|
449 | case 0x60:
|
450 | inTemplateString = true;
|
451 | break;
|
452 | case 0x28:
|
453 | paren++;
|
454 | break;
|
455 | case 0x29:
|
456 | paren--;
|
457 | break;
|
458 | case 0x5b:
|
459 | square++;
|
460 | break;
|
461 | case 0x5d:
|
462 | square--;
|
463 | break;
|
464 | case 0x7b:
|
465 | curly++;
|
466 | break;
|
467 | case 0x7d:
|
468 | curly--;
|
469 | break;
|
470 | }
|
471 | if (c === 0x2f) {
|
472 | let j = i - 1;
|
473 | let p;
|
474 | for (; j >= 0; j--) {
|
475 | p = exp.charAt(j);
|
476 | if (p !== " ") {
|
477 | break;
|
478 | }
|
479 | }
|
480 | if (!p || !validDivisionCharRE.test(p)) {
|
481 | inRegex = true;
|
482 | }
|
483 | }
|
484 | }
|
485 | }
|
486 | result.push(exp.slice(lastFilterIndex));
|
487 | return result;
|
488 | }
|
489 | function parseExpressionBody(code, locationCalculator, parserOptions, allowEmpty = false) {
|
490 | debug('[script] parse expression: "0(%s)"', code);
|
491 | try {
|
492 | const ast = parseScriptFragment(`0(${code})`, locationCalculator.getSubCalculatorAfter(-2), parserOptions).ast;
|
493 | const tokens = ast.tokens || [];
|
494 | const comments = ast.comments || [];
|
495 | const references = analyzeExternalReferences(ast, parserOptions);
|
496 | const statement = ast.body[0];
|
497 | const callExpression = statement.expression;
|
498 | const expression = callExpression.arguments[0];
|
499 | if (!allowEmpty && !expression) {
|
500 | return throwEmptyError(locationCalculator, "an expression");
|
501 | }
|
502 | if (expression && expression.type === "SpreadElement") {
|
503 | return throwUnexpectedTokenError("...", expression);
|
504 | }
|
505 | if (callExpression.arguments[1]) {
|
506 | const node = callExpression.arguments[1];
|
507 | return throwUnexpectedTokenError(",", getCommaTokenBeforeNode(tokens, node) || node);
|
508 | }
|
509 | tokens.shift();
|
510 | tokens.shift();
|
511 | tokens.pop();
|
512 | return { expression, tokens, comments, references, variables: [] };
|
513 | }
|
514 | catch (err) {
|
515 | return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
|
516 | }
|
517 | }
|
518 | function parseFilter(code, locationCalculator, parserOptions) {
|
519 | debug('[script] parse filter: "%s"', code);
|
520 | try {
|
521 | const expression = {
|
522 | type: "VFilter",
|
523 | parent: null,
|
524 | range: [0, 0],
|
525 | loc: {},
|
526 | callee: null,
|
527 | arguments: [],
|
528 | };
|
529 | const tokens = [];
|
530 | const comments = [];
|
531 | const references = [];
|
532 | const paren = code.indexOf("(");
|
533 | const calleeCode = paren === -1 ? code : code.slice(0, paren);
|
534 | const argsCode = paren === -1 ? null : code.slice(paren);
|
535 | if (calleeCode.trim()) {
|
536 | const spaces = /^\s*/u.exec(calleeCode)[0];
|
537 | const { ast } = parseScriptFragment(`${spaces}"${calleeCode.trim()}"`, locationCalculator, parserOptions);
|
538 | const statement = ast.body[0];
|
539 | const callee = statement.expression;
|
540 | if (callee.type !== "Literal") {
|
541 | const { loc, range } = ast.tokens[0];
|
542 | return throwUnexpectedTokenError('"', {
|
543 | range: [range[1] - 1, range[1]],
|
544 | loc: {
|
545 | start: {
|
546 | line: loc.end.line,
|
547 | column: loc.end.column - 1,
|
548 | },
|
549 | end: loc.end,
|
550 | },
|
551 | });
|
552 | }
|
553 | expression.callee = {
|
554 | type: "Identifier",
|
555 | parent: expression,
|
556 | range: [callee.range[0], callee.range[1] - 2],
|
557 | loc: {
|
558 | start: callee.loc.start,
|
559 | end: locationCalculator.getLocation(callee.range[1] - callee.range[0] - 1),
|
560 | },
|
561 | name: String(callee.value),
|
562 | };
|
563 | tokens.push({
|
564 | type: "Identifier",
|
565 | value: calleeCode.trim(),
|
566 | range: expression.callee.range,
|
567 | loc: expression.callee.loc,
|
568 | });
|
569 | }
|
570 | else {
|
571 | return throwEmptyError(locationCalculator, "a filter name");
|
572 | }
|
573 | if (argsCode != null) {
|
574 | const { ast } = parseScriptFragment(`0${argsCode}`, locationCalculator.getSubCalculatorAfter(paren - 1), parserOptions);
|
575 | const statement = ast.body[0];
|
576 | const callExpression = statement.expression;
|
577 | ast.tokens.shift();
|
578 | if (callExpression.type !== "CallExpression" ||
|
579 | callExpression.callee.type !== "Literal") {
|
580 | let nestCount = 1;
|
581 | for (const token of ast.tokens.slice(1)) {
|
582 | if (nestCount === 0) {
|
583 | return throwUnexpectedTokenError(token.value, token);
|
584 | }
|
585 | if (token.type === "Punctuator" && token.value === "(") {
|
586 | nestCount += 1;
|
587 | }
|
588 | if (token.type === "Punctuator" && token.value === ")") {
|
589 | nestCount -= 1;
|
590 | }
|
591 | }
|
592 | const token = last(ast.tokens);
|
593 | return throwUnexpectedTokenError(token.value, token);
|
594 | }
|
595 | for (const argument of callExpression.arguments) {
|
596 | argument.parent = expression;
|
597 | expression.arguments.push(argument);
|
598 | }
|
599 | tokens.push(...ast.tokens);
|
600 | comments.push(...ast.comments);
|
601 | references.push(...analyzeExternalReferences(ast, parserOptions));
|
602 | }
|
603 | const firstToken = tokens[0];
|
604 | const lastToken = last(tokens);
|
605 | expression.range = [firstToken.range[0], lastToken.range[1]];
|
606 | expression.loc = { start: firstToken.loc.start, end: lastToken.loc.end };
|
607 | return { expression, tokens, comments, references, variables: [] };
|
608 | }
|
609 | catch (err) {
|
610 | return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
|
611 | }
|
612 | }
|
613 | function parseScript(code, parserOptions) {
|
614 | const parser = typeof parserOptions.parser === "string"
|
615 | ?
|
616 | require(parserOptions.parser)
|
617 | : getEspree();
|
618 | const result = typeof parser.parseForESLint === "function"
|
619 | ? parser.parseForESLint(code, parserOptions)
|
620 | : parser.parse(code, parserOptions);
|
621 | if (result.ast != null) {
|
622 | return result;
|
623 | }
|
624 | return { ast: result };
|
625 | }
|
626 | function parseScriptElement(node, globalLocationCalculator, parserOptions) {
|
627 | const text = node.children[0];
|
628 | const offset = text != null && text.type === "VText"
|
629 | ? text.range[0]
|
630 | : node.startTag.range[1];
|
631 | const code = text != null && text.type === "VText" ? text.value : "";
|
632 | const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(offset);
|
633 | const result = parseScriptFragment(code, locationCalculator, parserOptions);
|
634 | if (result.ast.tokens != null) {
|
635 | const startTag = node.startTag;
|
636 | const endTag = node.endTag;
|
637 | if (startTag != null) {
|
638 | result.ast.tokens.unshift({
|
639 | type: "Punctuator",
|
640 | range: startTag.range,
|
641 | loc: startTag.loc,
|
642 | value: "<script>",
|
643 | });
|
644 | }
|
645 | if (endTag != null) {
|
646 | result.ast.tokens.push({
|
647 | type: "Punctuator",
|
648 | range: endTag.range,
|
649 | loc: endTag.loc,
|
650 | value: "</script>",
|
651 | });
|
652 | }
|
653 | }
|
654 | return result;
|
655 | }
|
656 | function parseExpression(code, locationCalculator, parserOptions, { allowEmpty = false, allowFilters = false } = {}) {
|
657 | debug('[script] parse expression: "%s"', code);
|
658 | const [mainCode, ...filterCodes] = allowFilters
|
659 | ? splitFilters(code)
|
660 | : [code];
|
661 | if (filterCodes.length === 0) {
|
662 | return parseExpressionBody(code, locationCalculator, parserOptions, allowEmpty);
|
663 | }
|
664 | const retB = parseExpressionBody(mainCode, locationCalculator, parserOptions);
|
665 | if (!retB.expression) {
|
666 | return retB;
|
667 | }
|
668 | const ret = retB;
|
669 | ret.expression = {
|
670 | type: "VFilterSequenceExpression",
|
671 | parent: null,
|
672 | expression: retB.expression,
|
673 | filters: [],
|
674 | range: retB.expression.range.slice(0),
|
675 | loc: Object.assign({}, retB.expression.loc),
|
676 | };
|
677 | ret.expression.expression.parent = ret.expression;
|
678 | let prevLoc = mainCode.length;
|
679 | for (const filterCode of filterCodes) {
|
680 | ret.tokens.push(locationCalculator.fixLocation({
|
681 | type: "Punctuator",
|
682 | value: "|",
|
683 | range: [prevLoc, prevLoc + 1],
|
684 | loc: {},
|
685 | }));
|
686 | const retF = parseFilter(filterCode, locationCalculator.getSubCalculatorAfter(prevLoc + 1), parserOptions);
|
687 | if (retF) {
|
688 | if (retF.expression) {
|
689 | ret.expression.filters.push(retF.expression);
|
690 | retF.expression.parent = ret.expression;
|
691 | }
|
692 | ret.tokens.push(...retF.tokens);
|
693 | ret.comments.push(...retF.comments);
|
694 | ret.references.push(...retF.references);
|
695 | }
|
696 | prevLoc += 1 + filterCode.length;
|
697 | }
|
698 | const lastToken = last(ret.tokens);
|
699 | ret.expression.range[1] = lastToken.range[1];
|
700 | ret.expression.loc.end = lastToken.loc.end;
|
701 | return ret;
|
702 | }
|
703 | function parseVForExpression(code, locationCalculator, parserOptions) {
|
704 | const processedCode = replaceAliasParens(code);
|
705 | debug('[script] parse v-for expression: "for(%s);"', processedCode);
|
706 | if (code.trim() === "") {
|
707 | throwEmptyError(locationCalculator, "'<alias> in <expression>'");
|
708 | }
|
709 | try {
|
710 | const replaced = processedCode !== code;
|
711 | const ast = parseScriptFragment(`for(let ${processedCode});`, locationCalculator.getSubCalculatorAfter(-8), parserOptions).ast;
|
712 | const tokens = ast.tokens || [];
|
713 | const comments = ast.comments || [];
|
714 | const scope = analyzeVariablesAndExternalReferences(ast, parserOptions);
|
715 | const references = scope.references;
|
716 | const variables = scope.variables;
|
717 | const statement = ast.body[0];
|
718 | const left = normalizeLeft(statement.left, replaced);
|
719 | const right = statement.right;
|
720 | const firstToken = tokens[3] || statement.left;
|
721 | const lastToken = tokens[tokens.length - 3] || statement.right;
|
722 | const expression = {
|
723 | type: "VForExpression",
|
724 | range: [firstToken.range[0], lastToken.range[1]],
|
725 | loc: { start: firstToken.loc.start, end: lastToken.loc.end },
|
726 | parent: DUMMY_PARENT,
|
727 | left,
|
728 | right,
|
729 | };
|
730 | for (const l of left) {
|
731 | if (l != null) {
|
732 | l.parent = expression;
|
733 | }
|
734 | }
|
735 | right.parent = expression;
|
736 | tokens.shift();
|
737 | tokens.shift();
|
738 | tokens.shift();
|
739 | tokens.pop();
|
740 | tokens.pop();
|
741 | if (replaced) {
|
742 | const closeOffset = statement.left.range[1] - 1;
|
743 | const open = tokens[0];
|
744 | const close = tokens.find(t => t.range[0] === closeOffset);
|
745 | if (open != null) {
|
746 | open.value = "(";
|
747 | }
|
748 | if (close != null) {
|
749 | close.value = ")";
|
750 | }
|
751 | }
|
752 | return { expression, tokens, comments, references, variables };
|
753 | }
|
754 | catch (err) {
|
755 | return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
|
756 | }
|
757 | }
|
758 | function parseVOnExpression(code, locationCalculator, parserOptions) {
|
759 | if (IS_FUNCTION_EXPRESSION.test(code) || IS_SIMPLE_PATH.test(code)) {
|
760 | return parseExpressionBody(code, locationCalculator, parserOptions);
|
761 | }
|
762 | return parseVOnExpressionBody(code, locationCalculator, parserOptions);
|
763 | }
|
764 | function parseVOnExpressionBody(code, locationCalculator, parserOptions) {
|
765 | debug('[script] parse v-on expression: "void function($event){%s}"', code);
|
766 | if (code.trim() === "") {
|
767 | throwEmptyError(locationCalculator, "statements");
|
768 | }
|
769 | try {
|
770 | const ast = parseScriptFragment(`void function($event){${code}}`, locationCalculator.getSubCalculatorAfter(-22), parserOptions).ast;
|
771 | const references = analyzeExternalReferences(ast, parserOptions);
|
772 | const outermostStatement = ast.body[0];
|
773 | const functionDecl = outermostStatement.expression
|
774 | .argument;
|
775 | const block = functionDecl.body;
|
776 | const body = block.body;
|
777 | const firstStatement = first(body);
|
778 | const lastStatement = last(body);
|
779 | const expression = {
|
780 | type: "VOnExpression",
|
781 | range: [
|
782 | firstStatement != null
|
783 | ? firstStatement.range[0]
|
784 | : block.range[0] + 1,
|
785 | lastStatement != null
|
786 | ? lastStatement.range[1]
|
787 | : block.range[1] - 1,
|
788 | ],
|
789 | loc: {
|
790 | start: firstStatement != null
|
791 | ? firstStatement.loc.start
|
792 | : locationCalculator.getLocation(1),
|
793 | end: lastStatement != null
|
794 | ? lastStatement.loc.end
|
795 | : locationCalculator.getLocation(code.length + 1),
|
796 | },
|
797 | parent: DUMMY_PARENT,
|
798 | body,
|
799 | };
|
800 | const tokens = ast.tokens || [];
|
801 | const comments = ast.comments || [];
|
802 | for (const b of body) {
|
803 | b.parent = expression;
|
804 | }
|
805 | tokens.splice(0, 6);
|
806 | tokens.pop();
|
807 | return { expression, tokens, comments, references, variables: [] };
|
808 | }
|
809 | catch (err) {
|
810 | return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
|
811 | }
|
812 | }
|
813 | function parseSlotScopeExpression(code, locationCalculator, parserOptions) {
|
814 | debug('[script] parse slot-scope expression: "void function(%s) {}"', code);
|
815 | if (code.trim() === "") {
|
816 | throwEmptyError(locationCalculator, "an identifier or an array/object pattern");
|
817 | }
|
818 | try {
|
819 | const ast = parseScriptFragment(`void function(${code}) {}`, locationCalculator.getSubCalculatorAfter(-14), parserOptions).ast;
|
820 | const statement = ast.body[0];
|
821 | const rawExpression = statement.expression;
|
822 | const functionDecl = rawExpression.argument;
|
823 | const params = functionDecl.params;
|
824 | if (params.length === 0) {
|
825 | return {
|
826 | expression: null,
|
827 | tokens: [],
|
828 | comments: [],
|
829 | references: [],
|
830 | variables: [],
|
831 | };
|
832 | }
|
833 | const tokens = ast.tokens || [];
|
834 | const comments = ast.comments || [];
|
835 | const scope = analyzeVariablesAndExternalReferences(ast, parserOptions);
|
836 | const references = scope.references;
|
837 | const variables = scope.variables;
|
838 | const firstParam = first(params);
|
839 | const lastParam = last(params);
|
840 | const expression = {
|
841 | type: "VSlotScopeExpression",
|
842 | range: [firstParam.range[0], lastParam.range[1]],
|
843 | loc: { start: firstParam.loc.start, end: lastParam.loc.end },
|
844 | parent: DUMMY_PARENT,
|
845 | params: functionDecl.params,
|
846 | };
|
847 | for (const param of params) {
|
848 | param.parent = expression;
|
849 | }
|
850 | tokens.shift();
|
851 | tokens.shift();
|
852 | tokens.shift();
|
853 | tokens.pop();
|
854 | tokens.pop();
|
855 | tokens.pop();
|
856 | return { expression, tokens, comments, references, variables };
|
857 | }
|
858 | catch (err) {
|
859 | return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
|
860 | }
|
861 | }
|
862 |
|
863 | const shorthandSign = /^[.:@#]/u;
|
864 | const shorthandNameMap = { ":": "bind", ".": "bind", "@": "on", "#": "slot" };
|
865 | const invalidDynamicArgumentNextChar = /^[\s\r\n=/>]$/u;
|
866 | function getOwnerDocument(leafNode) {
|
867 | let node = leafNode;
|
868 | while (node != null && node.type !== "VDocumentFragment") {
|
869 | node = node.parent;
|
870 | }
|
871 | return node;
|
872 | }
|
873 | function createSimpleToken(type, start, end, value, globalLocationCalculator) {
|
874 | return {
|
875 | type,
|
876 | range: [start, end],
|
877 | loc: {
|
878 | start: globalLocationCalculator.getLocation(start),
|
879 | end: globalLocationCalculator.getLocation(end),
|
880 | },
|
881 | value,
|
882 | };
|
883 | }
|
884 | function parseDirectiveKeyStatically(node, document) {
|
885 | const { name: text, rawName: rawText, range: [offset], loc: { start: { column, line }, }, } = node;
|
886 | const directiveKey = {
|
887 | type: "VDirectiveKey",
|
888 | range: node.range,
|
889 | loc: node.loc,
|
890 | parent: node.parent,
|
891 | name: null,
|
892 | argument: null,
|
893 | modifiers: [],
|
894 | };
|
895 | let i = 0;
|
896 | function createIdentifier(start, end, name) {
|
897 | return {
|
898 | type: "VIdentifier",
|
899 | parent: directiveKey,
|
900 | range: [offset + start, offset + end],
|
901 | loc: {
|
902 | start: { column: column + start, line },
|
903 | end: { column: column + end, line },
|
904 | },
|
905 | name: name || text.slice(start, end),
|
906 | rawName: rawText.slice(start, end),
|
907 | };
|
908 | }
|
909 | if (shorthandSign.test(text)) {
|
910 | const sign = text[0];
|
911 | directiveKey.name = createIdentifier(0, 1, shorthandNameMap[sign]);
|
912 | i = 1;
|
913 | }
|
914 | else {
|
915 | const colon = text.indexOf(":");
|
916 | if (colon !== -1) {
|
917 | directiveKey.name = createIdentifier(0, colon);
|
918 | i = colon + 1;
|
919 | }
|
920 | }
|
921 | if (directiveKey.name != null && text[i] === "[") {
|
922 | const len = text.slice(i).lastIndexOf("]");
|
923 | if (len !== -1) {
|
924 | directiveKey.argument = createIdentifier(i, i + len + 1);
|
925 | i = i + len + 1 + (text[i + len + 1] === "." ? 1 : 0);
|
926 | }
|
927 | }
|
928 | const modifiers = text
|
929 | .slice(i)
|
930 | .split(".")
|
931 | .map(modifierName => {
|
932 | const modifier = createIdentifier(i, i + modifierName.length);
|
933 | if (modifierName === "" && i < text.length) {
|
934 | insertError(document, new ParseError(`Unexpected token '${text[i]}'`, undefined, offset + i, line, column + i));
|
935 | }
|
936 | i += modifierName.length + 1;
|
937 | return modifier;
|
938 | });
|
939 | if (directiveKey.name == null) {
|
940 | directiveKey.name = modifiers.shift();
|
941 | }
|
942 | else if (directiveKey.argument == null && modifiers[0].name !== "") {
|
943 | directiveKey.argument = modifiers.shift() || null;
|
944 | }
|
945 | directiveKey.modifiers = modifiers.filter(isNotEmptyModifier);
|
946 | if (directiveKey.name.name === "v-") {
|
947 | insertError(document, new ParseError(`Unexpected token '${text[directiveKey.name.range[1] - offset]}'`, undefined, directiveKey.name.range[1], directiveKey.name.loc.end.line, directiveKey.name.loc.end.column));
|
948 | }
|
949 | if (directiveKey.name.rawName === "." &&
|
950 | !directiveKey.modifiers.some(isPropModifier)) {
|
951 | const pos = (directiveKey.argument || directiveKey.name).range[1] - offset;
|
952 | const propModifier = createIdentifier(pos, pos, "prop");
|
953 | directiveKey.modifiers.unshift(propModifier);
|
954 | }
|
955 | return directiveKey;
|
956 | }
|
957 | function isPropModifier(node) {
|
958 | return node.name === "prop";
|
959 | }
|
960 | function isNotEmptyModifier(node) {
|
961 | return node.name !== "";
|
962 | }
|
963 | function parseDirectiveKeyTokens(node) {
|
964 | const { name, argument, modifiers } = node;
|
965 | const shorthand = name.range[1] - name.range[0] === 1;
|
966 | const tokens = [];
|
967 | if (shorthand) {
|
968 | tokens.push({
|
969 | type: "Punctuator",
|
970 | range: name.range,
|
971 | loc: name.loc,
|
972 | value: name.rawName,
|
973 | });
|
974 | }
|
975 | else {
|
976 | tokens.push({
|
977 | type: "HTMLIdentifier",
|
978 | range: name.range,
|
979 | loc: name.loc,
|
980 | value: name.rawName,
|
981 | });
|
982 | if (argument) {
|
983 | tokens.push({
|
984 | type: "Punctuator",
|
985 | range: [name.range[1], argument.range[0]],
|
986 | loc: { start: name.loc.end, end: argument.loc.start },
|
987 | value: ":",
|
988 | });
|
989 | }
|
990 | }
|
991 | if (argument) {
|
992 | tokens.push({
|
993 | type: "HTMLIdentifier",
|
994 | range: argument.range,
|
995 | loc: argument.loc,
|
996 | value: argument.rawName,
|
997 | });
|
998 | }
|
999 | let lastNode = argument || name;
|
1000 | for (const modifier of modifiers) {
|
1001 | if (modifier.rawName === "") {
|
1002 | continue;
|
1003 | }
|
1004 | tokens.push({
|
1005 | type: "Punctuator",
|
1006 | range: [lastNode.range[1], modifier.range[0]],
|
1007 | loc: { start: lastNode.loc.end, end: modifier.loc.start },
|
1008 | value: ".",
|
1009 | }, {
|
1010 | type: "HTMLIdentifier",
|
1011 | range: modifier.range,
|
1012 | loc: modifier.loc,
|
1013 | value: modifier.rawName,
|
1014 | });
|
1015 | lastNode = modifier;
|
1016 | }
|
1017 | return tokens;
|
1018 | }
|
1019 | function convertDynamicArgument(node, document, parserOptions, locationCalculator) {
|
1020 | const { argument } = node;
|
1021 | if (!(argument != null &&
|
1022 | argument.type === "VIdentifier" &&
|
1023 | argument.name.startsWith("[") &&
|
1024 | argument.name.endsWith("]"))) {
|
1025 | return;
|
1026 | }
|
1027 | const { rawName, range, loc } = argument;
|
1028 | try {
|
1029 | const { comments, expression, references, tokens } = parseExpression(rawName.slice(1, -1), locationCalculator.getSubCalculatorAfter(range[0] + 1), parserOptions);
|
1030 | node.argument = {
|
1031 | type: "VExpressionContainer",
|
1032 | range,
|
1033 | loc,
|
1034 | parent: node,
|
1035 | expression,
|
1036 | references,
|
1037 | };
|
1038 | if (expression != null) {
|
1039 | expression.parent = node.argument;
|
1040 | }
|
1041 | tokens.unshift(createSimpleToken("Punctuator", range[0], range[0] + 1, "[", locationCalculator));
|
1042 | tokens.push(createSimpleToken("Punctuator", range[1] - 1, range[1], "]", locationCalculator));
|
1043 | replaceTokens(document, node.argument, tokens);
|
1044 | insertComments(document, comments);
|
1045 | }
|
1046 | catch (error) {
|
1047 | debug("[template] Parse error: %s", error);
|
1048 | if (ParseError.isParseError(error)) {
|
1049 | node.argument = {
|
1050 | type: "VExpressionContainer",
|
1051 | range,
|
1052 | loc,
|
1053 | parent: node,
|
1054 | expression: null,
|
1055 | references: [],
|
1056 | };
|
1057 | insertError(document, error);
|
1058 | }
|
1059 | else {
|
1060 | throw error;
|
1061 | }
|
1062 | }
|
1063 | }
|
1064 | function createDirectiveKey(node, document, parserOptions, locationCalculator) {
|
1065 | const directiveKey = parseDirectiveKeyStatically(node, document);
|
1066 | const tokens = parseDirectiveKeyTokens(directiveKey);
|
1067 | replaceTokens(document, directiveKey, tokens);
|
1068 | if (directiveKey.name.name.startsWith("v-")) {
|
1069 | directiveKey.name.name = directiveKey.name.name.slice(2);
|
1070 | }
|
1071 | if (directiveKey.name.rawName.startsWith("v-")) {
|
1072 | directiveKey.name.rawName = directiveKey.name.rawName.slice(2);
|
1073 | }
|
1074 | convertDynamicArgument(directiveKey, document, parserOptions, locationCalculator);
|
1075 | return directiveKey;
|
1076 | }
|
1077 | function byRange0(x) {
|
1078 | return x.range[0];
|
1079 | }
|
1080 | function byRange1(x) {
|
1081 | return x.range[1];
|
1082 | }
|
1083 | function byIndex(x) {
|
1084 | return x.index;
|
1085 | }
|
1086 | function replaceTokens(document, node, newTokens) {
|
1087 | if (document == null) {
|
1088 | return;
|
1089 | }
|
1090 | const index = sortedIndexBy(document.tokens, node, byRange0);
|
1091 | const count = sortedLastIndexBy(document.tokens, node, byRange1) - index;
|
1092 | document.tokens.splice(index, count, ...newTokens);
|
1093 | }
|
1094 | function insertComments(document, newComments) {
|
1095 | if (document == null || newComments.length === 0) {
|
1096 | return;
|
1097 | }
|
1098 | const index = sortedIndexBy(document.comments, newComments[0], byRange0);
|
1099 | document.comments.splice(index, 0, ...newComments);
|
1100 | }
|
1101 | function insertError(document, error) {
|
1102 | if (document == null) {
|
1103 | return;
|
1104 | }
|
1105 | const index = sortedIndexBy(document.errors, error, byIndex);
|
1106 | document.errors.splice(index, 0, error);
|
1107 | }
|
1108 | function parseAttributeValue(code, parserOptions, globalLocationCalculator, node, tagName, directiveKey) {
|
1109 | const firstChar = code[node.range[0]];
|
1110 | const quoted = firstChar === '"' || firstChar === "'";
|
1111 | const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(node.range[0] + (quoted ? 1 : 0));
|
1112 | const directiveName = directiveKey.name.name;
|
1113 | let result;
|
1114 | if (quoted && node.value === "") {
|
1115 | result = {
|
1116 | expression: null,
|
1117 | tokens: [],
|
1118 | comments: [],
|
1119 | variables: [],
|
1120 | references: [],
|
1121 | };
|
1122 | }
|
1123 | else if (directiveName === "for") {
|
1124 | result = parseVForExpression(node.value, locationCalculator, parserOptions);
|
1125 | }
|
1126 | else if (directiveName === "on" && directiveKey.argument != null) {
|
1127 | result = parseVOnExpression(node.value, locationCalculator, parserOptions);
|
1128 | }
|
1129 | else if (directiveName === "slot" ||
|
1130 | directiveName === "slot-scope" ||
|
1131 | (tagName === "template" && directiveName === "scope")) {
|
1132 | result = parseSlotScopeExpression(node.value, locationCalculator, parserOptions);
|
1133 | }
|
1134 | else if (directiveName === "bind") {
|
1135 | result = parseExpression(node.value, locationCalculator, parserOptions, { allowFilters: true });
|
1136 | }
|
1137 | else {
|
1138 | result = parseExpression(node.value, locationCalculator, parserOptions);
|
1139 | }
|
1140 | if (quoted) {
|
1141 | result.tokens.unshift(createSimpleToken("Punctuator", node.range[0], node.range[0] + 1, firstChar, globalLocationCalculator));
|
1142 | result.tokens.push(createSimpleToken("Punctuator", node.range[1] - 1, node.range[1], firstChar, globalLocationCalculator));
|
1143 | }
|
1144 | return result;
|
1145 | }
|
1146 | function resolveReference(referene, element) {
|
1147 | let node = element;
|
1148 | while (node != null && node.type === "VElement") {
|
1149 | for (const variable of node.variables) {
|
1150 | if (variable.id.name === referene.id.name) {
|
1151 | referene.variable = variable;
|
1152 | variable.references.push(referene);
|
1153 | return;
|
1154 | }
|
1155 | }
|
1156 | node = node.parent;
|
1157 | }
|
1158 | }
|
1159 | function convertToDirective(code, parserOptions, locationCalculator, node) {
|
1160 | debug('[template] convert to directive: %s="%s" %j', node.key.name, node.value && node.value.value, node.range);
|
1161 | const document = getOwnerDocument(node);
|
1162 | const directive = node;
|
1163 | directive.directive = true;
|
1164 | directive.key = createDirectiveKey(node.key, document, parserOptions, locationCalculator);
|
1165 | const { argument } = directive.key;
|
1166 | if (argument &&
|
1167 | argument.type === "VIdentifier" &&
|
1168 | argument.name.startsWith("[")) {
|
1169 | const nextChar = code[argument.range[1]];
|
1170 | if (nextChar == null || invalidDynamicArgumentNextChar.test(nextChar)) {
|
1171 | const char = nextChar == null ? "EOF" : JSON.stringify(nextChar).slice(1, -1);
|
1172 | insertError(document, new ParseError(`Dynamic argument cannot contain the '${char}' character.`, undefined, argument.range[1], argument.loc.end.line, argument.loc.end.column));
|
1173 | }
|
1174 | }
|
1175 | if (node.value == null) {
|
1176 | return;
|
1177 | }
|
1178 | try {
|
1179 | const ret = parseAttributeValue(code, parserOptions, locationCalculator, node.value, node.parent.parent.name, directive.key);
|
1180 | directive.value = {
|
1181 | type: "VExpressionContainer",
|
1182 | range: node.value.range,
|
1183 | loc: node.value.loc,
|
1184 | parent: directive,
|
1185 | expression: ret.expression,
|
1186 | references: ret.references,
|
1187 | };
|
1188 | if (ret.expression != null) {
|
1189 | ret.expression.parent = directive.value;
|
1190 | }
|
1191 | for (const variable of ret.variables) {
|
1192 | node.parent.parent.variables.push(variable);
|
1193 | }
|
1194 | replaceTokens(document, node.value, ret.tokens);
|
1195 | insertComments(document, ret.comments);
|
1196 | }
|
1197 | catch (err) {
|
1198 | debug("[template] Parse error: %s", err);
|
1199 | if (ParseError.isParseError(err)) {
|
1200 | directive.value = {
|
1201 | type: "VExpressionContainer",
|
1202 | range: node.value.range,
|
1203 | loc: node.value.loc,
|
1204 | parent: directive,
|
1205 | expression: null,
|
1206 | references: [],
|
1207 | };
|
1208 | insertError(document, err);
|
1209 | }
|
1210 | else {
|
1211 | throw err;
|
1212 | }
|
1213 | }
|
1214 | }
|
1215 | function processMustache(parserOptions, globalLocationCalculator, node, mustache) {
|
1216 | const range = [
|
1217 | mustache.startToken.range[1],
|
1218 | mustache.endToken.range[0],
|
1219 | ];
|
1220 | debug("[template] convert mustache {{%s}} %j", mustache.value, range);
|
1221 | const document = getOwnerDocument(node);
|
1222 | try {
|
1223 | const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(range[0]);
|
1224 | const ret = parseExpression(mustache.value, locationCalculator, parserOptions, { allowEmpty: true, allowFilters: true });
|
1225 | node.expression = ret.expression || null;
|
1226 | node.references = ret.references;
|
1227 | if (ret.expression != null) {
|
1228 | ret.expression.parent = node;
|
1229 | }
|
1230 | replaceTokens(document, { range }, ret.tokens);
|
1231 | insertComments(document, ret.comments);
|
1232 | }
|
1233 | catch (err) {
|
1234 | debug("[template] Parse error: %s", err);
|
1235 | if (ParseError.isParseError(err)) {
|
1236 | insertError(document, err);
|
1237 | }
|
1238 | else {
|
1239 | throw err;
|
1240 | }
|
1241 | }
|
1242 | }
|
1243 | function resolveReferences(container) {
|
1244 | let element = container.parent;
|
1245 | while (element != null && element.type !== "VElement") {
|
1246 | element = element.parent;
|
1247 | }
|
1248 | if (element != null) {
|
1249 | for (const reference of container.references) {
|
1250 | resolveReference(reference, element);
|
1251 | }
|
1252 | }
|
1253 | }
|
1254 |
|
1255 | const SVG_ATTRIBUTE_NAME_MAP = new Map([
|
1256 | ["attributename", "attributeName"],
|
1257 | ["attributetype", "attributeType"],
|
1258 | ["basefrequency", "baseFrequency"],
|
1259 | ["baseprofile", "baseProfile"],
|
1260 | ["calcmode", "calcMode"],
|
1261 | ["clippathunits", "clipPathUnits"],
|
1262 | ["diffuseconstant", "diffuseConstant"],
|
1263 | ["edgemode", "edgeMode"],
|
1264 | ["filterunits", "filterUnits"],
|
1265 | ["glyphref", "glyphRef"],
|
1266 | ["gradienttransform", "gradientTransform"],
|
1267 | ["gradientunits", "gradientUnits"],
|
1268 | ["kernelmatrix", "kernelMatrix"],
|
1269 | ["kernelunitlength", "kernelUnitLength"],
|
1270 | ["keypoints", "keyPoints"],
|
1271 | ["keysplines", "keySplines"],
|
1272 | ["keytimes", "keyTimes"],
|
1273 | ["lengthadjust", "lengthAdjust"],
|
1274 | ["limitingconeangle", "limitingConeAngle"],
|
1275 | ["markerheight", "markerHeight"],
|
1276 | ["markerunits", "markerUnits"],
|
1277 | ["markerwidth", "markerWidth"],
|
1278 | ["maskcontentunits", "maskContentUnits"],
|
1279 | ["maskunits", "maskUnits"],
|
1280 | ["numoctaves", "numOctaves"],
|
1281 | ["pathlength", "pathLength"],
|
1282 | ["patterncontentunits", "patternContentUnits"],
|
1283 | ["patterntransform", "patternTransform"],
|
1284 | ["patternunits", "patternUnits"],
|
1285 | ["pointsatx", "pointsAtX"],
|
1286 | ["pointsaty", "pointsAtY"],
|
1287 | ["pointsatz", "pointsAtZ"],
|
1288 | ["preservealpha", "preserveAlpha"],
|
1289 | ["preserveaspectratio", "preserveAspectRatio"],
|
1290 | ["primitiveunits", "primitiveUnits"],
|
1291 | ["refx", "refX"],
|
1292 | ["refy", "refY"],
|
1293 | ["repeatcount", "repeatCount"],
|
1294 | ["repeatdur", "repeatDur"],
|
1295 | ["requiredextensions", "requiredExtensions"],
|
1296 | ["requiredfeatures", "requiredFeatures"],
|
1297 | ["specularconstant", "specularConstant"],
|
1298 | ["specularexponent", "specularExponent"],
|
1299 | ["spreadmethod", "spreadMethod"],
|
1300 | ["startoffset", "startOffset"],
|
1301 | ["stddeviation", "stdDeviation"],
|
1302 | ["stitchtiles", "stitchTiles"],
|
1303 | ["surfacescale", "surfaceScale"],
|
1304 | ["systemlanguage", "systemLanguage"],
|
1305 | ["tablevalues", "tableValues"],
|
1306 | ["targetx", "targetX"],
|
1307 | ["targety", "targetY"],
|
1308 | ["textlength", "textLength"],
|
1309 | ["viewbox", "viewBox"],
|
1310 | ["viewtarget", "viewTarget"],
|
1311 | ["xchannelselector", "xChannelSelector"],
|
1312 | ["ychannelselector", "yChannelSelector"],
|
1313 | ["zoomandpan", "zoomAndPan"],
|
1314 | ]);
|
1315 | const MATHML_ATTRIBUTE_NAME_MAP = new Map([
|
1316 | ["definitionurl", "definitionUrl"]
|
1317 | ]);
|
1318 |
|
1319 | const HTML_VOID_ELEMENT_TAGS = new Set([
|
1320 | "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta",
|
1321 | "param", "source", "track", "wbr",
|
1322 | ]);
|
1323 | const HTML_CAN_BE_LEFT_OPEN_TAGS = new Set([
|
1324 | "colgroup", "li", "options", "p", "td", "tfoot", "th", "thead",
|
1325 | "tr", "source",
|
1326 | ]);
|
1327 | const HTML_NON_FHRASING_TAGS = new Set([
|
1328 | "address", "article", "aside", "base", "blockquote", "body", "caption",
|
1329 | "col", "colgroup", "dd", "details", "dialog", "div", "dl", "dt", "fieldset",
|
1330 | "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5",
|
1331 | "h6", "head", "header", "hgroup", "hr", "html", "legend", "li", "menuitem",
|
1332 | "meta", "optgroup", "option", "param", "rp", "rt", "source", "style",
|
1333 | "summary", "tbody", "td", "tfoot", "th", "thead", "title", "tr", "track",
|
1334 | ]);
|
1335 | const HTML_RCDATA_TAGS = new Set([
|
1336 | "title", "textarea",
|
1337 | ]);
|
1338 | const HTML_RAWTEXT_TAGS = new Set([
|
1339 | "style", "xmp", "iframe", "noembed", "noframes", "noscript", "script",
|
1340 | ]);
|
1341 | const SVG_TAGS = new Set([
|
1342 | "a", "altGlyph", "altGlyphDef", "altGlyphItem", "animate", "animateColor",
|
1343 | "animateMotion", "animateTransform", "animation", "audio", "canvas",
|
1344 | "circle", "clipPath", "color-profile", "cursor", "defs", "desc", "discard",
|
1345 | "ellipse", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite",
|
1346 | "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap",
|
1347 | "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB",
|
1348 | "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode",
|
1349 | "feMorphology", "feOffset", "fePointLight", "feSpecularLighting",
|
1350 | "feSpotLight", "feTile", "feTurbulence", "filter", "font", "font-face",
|
1351 | "font-face-format", "font-face-name", "font-face-src", "font-face-uri",
|
1352 | "foreignObject", "g", "glyph", "glyphRef", "handler", "hatch", "hatchpath",
|
1353 | "hkern", "iframe", "image", "line", "linearGradient", "listener", "marker",
|
1354 | "mask", "mesh", "meshgradient", "meshpatch", "meshrow", "metadata",
|
1355 | "missing-glyph", "mpath", "path", "pattern", "polygon", "polyline",
|
1356 | "prefetch", "radialGradient", "rect", "script", "set", "solidColor",
|
1357 | "solidcolor", "stop", "style", "svg", "switch", "symbol", "tbreak", "text",
|
1358 | "textArea", "textPath", "title", "tref", "tspan", "unknown", "use", "video",
|
1359 | "view", "vkern",
|
1360 | ]);
|
1361 | const SVG_ELEMENT_NAME_MAP = new Map();
|
1362 | for (const name of SVG_TAGS) {
|
1363 | if (/[A-Z]/.test(name)) {
|
1364 | SVG_ELEMENT_NAME_MAP.set(name.toLowerCase(), name);
|
1365 | }
|
1366 | }
|
1367 |
|
1368 | const DUMMY_PARENT$1 = Object.freeze({});
|
1369 | function concat(text, token) {
|
1370 | return text + token.value;
|
1371 | }
|
1372 | class IntermediateTokenizer {
|
1373 | get text() {
|
1374 | return this.tokenizer.text;
|
1375 | }
|
1376 | get errors() {
|
1377 | return this.tokenizer.errors;
|
1378 | }
|
1379 | get state() {
|
1380 | return this.tokenizer.state;
|
1381 | }
|
1382 | set state(value) {
|
1383 | this.tokenizer.state = value;
|
1384 | }
|
1385 | get namespace() {
|
1386 | return this.tokenizer.namespace;
|
1387 | }
|
1388 | set namespace(value) {
|
1389 | this.tokenizer.namespace = value;
|
1390 | }
|
1391 | get expressionEnabled() {
|
1392 | return this.tokenizer.expressionEnabled;
|
1393 | }
|
1394 | set expressionEnabled(value) {
|
1395 | this.tokenizer.expressionEnabled = value;
|
1396 | }
|
1397 | constructor(tokenizer) {
|
1398 | this.tokenizer = tokenizer;
|
1399 | this.currentToken = null;
|
1400 | this.attribute = null;
|
1401 | this.attributeNames = new Set();
|
1402 | this.expressionStartToken = null;
|
1403 | this.expressionTokens = [];
|
1404 | this.tokens = [];
|
1405 | this.comments = [];
|
1406 | }
|
1407 | nextToken() {
|
1408 | let token = null;
|
1409 | let result = null;
|
1410 | while (result == null && (token = this.tokenizer.nextToken()) != null) {
|
1411 | result = this[token.type](token);
|
1412 | }
|
1413 | if (result == null && token == null && this.currentToken != null) {
|
1414 | result = this.commit();
|
1415 | }
|
1416 | return result;
|
1417 | }
|
1418 | commit() {
|
1419 | assert(this.currentToken != null || this.expressionStartToken != null);
|
1420 | let token = this.currentToken;
|
1421 | this.currentToken = null;
|
1422 | this.attribute = null;
|
1423 | if (this.expressionStartToken != null) {
|
1424 | const start = this.expressionStartToken;
|
1425 | const end = last(this.expressionTokens) || start;
|
1426 | const value = this.expressionTokens.reduce(concat, start.value);
|
1427 | this.expressionStartToken = null;
|
1428 | this.expressionTokens = [];
|
1429 | if (token == null) {
|
1430 | token = {
|
1431 | type: "Text",
|
1432 | range: [start.range[0], end.range[1]],
|
1433 | loc: { start: start.loc.start, end: end.loc.end },
|
1434 | value,
|
1435 | };
|
1436 | }
|
1437 | else if (token.type === "Text") {
|
1438 | token.range[1] = end.range[1];
|
1439 | token.loc.end = end.loc.end;
|
1440 | token.value += value;
|
1441 | }
|
1442 | else {
|
1443 | throw new Error("unreachable");
|
1444 | }
|
1445 | }
|
1446 | return token;
|
1447 | }
|
1448 | reportParseError(token, code) {
|
1449 | const error = ParseError.fromCode(code, token.range[0], token.loc.start.line, token.loc.start.column);
|
1450 | this.errors.push(error);
|
1451 | debug("[html] syntax error:", error.message);
|
1452 | }
|
1453 | processComment(token) {
|
1454 | this.comments.push(token);
|
1455 | if (this.currentToken != null && this.currentToken.type === "Text") {
|
1456 | return this.commit();
|
1457 | }
|
1458 | return null;
|
1459 | }
|
1460 | processText(token) {
|
1461 | this.tokens.push(token);
|
1462 | let result = null;
|
1463 | if (this.expressionStartToken != null) {
|
1464 | const lastToken = last(this.expressionTokens) || this.expressionStartToken;
|
1465 | if (lastToken.range[1] === token.range[0]) {
|
1466 | this.expressionTokens.push(token);
|
1467 | return null;
|
1468 | }
|
1469 | result = this.commit();
|
1470 | }
|
1471 | else if (this.currentToken != null) {
|
1472 | if (this.currentToken.type === "Text" &&
|
1473 | this.currentToken.range[1] === token.range[0]) {
|
1474 | this.currentToken.value += token.value;
|
1475 | this.currentToken.range[1] = token.range[1];
|
1476 | this.currentToken.loc.end = token.loc.end;
|
1477 | return null;
|
1478 | }
|
1479 | result = this.commit();
|
1480 | }
|
1481 | assert(this.currentToken == null);
|
1482 | this.currentToken = {
|
1483 | type: "Text",
|
1484 | range: [token.range[0], token.range[1]],
|
1485 | loc: { start: token.loc.start, end: token.loc.end },
|
1486 | value: token.value,
|
1487 | };
|
1488 | return result;
|
1489 | }
|
1490 | HTMLAssociation(token) {
|
1491 | this.tokens.push(token);
|
1492 | if (this.attribute != null) {
|
1493 | this.attribute.range[1] = token.range[1];
|
1494 | this.attribute.loc.end = token.loc.end;
|
1495 | if (this.currentToken == null ||
|
1496 | this.currentToken.type !== "StartTag") {
|
1497 | throw new Error("unreachable");
|
1498 | }
|
1499 | this.currentToken.range[1] = token.range[1];
|
1500 | this.currentToken.loc.end = token.loc.end;
|
1501 | }
|
1502 | return null;
|
1503 | }
|
1504 | HTMLBogusComment(token) {
|
1505 | return this.processComment(token);
|
1506 | }
|
1507 | HTMLCDataText(token) {
|
1508 | return this.processText(token);
|
1509 | }
|
1510 | HTMLComment(token) {
|
1511 | return this.processComment(token);
|
1512 | }
|
1513 | HTMLEndTagOpen(token) {
|
1514 | this.tokens.push(token);
|
1515 | let result = null;
|
1516 | if (this.currentToken != null || this.expressionStartToken != null) {
|
1517 | result = this.commit();
|
1518 | }
|
1519 | this.currentToken = {
|
1520 | type: "EndTag",
|
1521 | range: [token.range[0], token.range[1]],
|
1522 | loc: { start: token.loc.start, end: token.loc.end },
|
1523 | name: token.value,
|
1524 | };
|
1525 | return result;
|
1526 | }
|
1527 | HTMLIdentifier(token) {
|
1528 | this.tokens.push(token);
|
1529 | if (this.currentToken == null ||
|
1530 | this.currentToken.type === "Text" ||
|
1531 | this.currentToken.type === "Mustache") {
|
1532 | throw new Error("unreachable");
|
1533 | }
|
1534 | if (this.currentToken.type === "EndTag") {
|
1535 | this.reportParseError(token, "end-tag-with-attributes");
|
1536 | return null;
|
1537 | }
|
1538 | if (this.attributeNames.has(token.value)) {
|
1539 | this.reportParseError(token, "duplicate-attribute");
|
1540 | }
|
1541 | this.attributeNames.add(token.value);
|
1542 | this.attribute = {
|
1543 | type: "VAttribute",
|
1544 | range: [token.range[0], token.range[1]],
|
1545 | loc: { start: token.loc.start, end: token.loc.end },
|
1546 | parent: DUMMY_PARENT$1,
|
1547 | directive: false,
|
1548 | key: {
|
1549 | type: "VIdentifier",
|
1550 | range: [token.range[0], token.range[1]],
|
1551 | loc: { start: token.loc.start, end: token.loc.end },
|
1552 | parent: DUMMY_PARENT$1,
|
1553 | name: token.value,
|
1554 | rawName: this.text.slice(token.range[0], token.range[1]),
|
1555 | },
|
1556 | value: null,
|
1557 | };
|
1558 | this.attribute.key.parent = this.attribute;
|
1559 | this.currentToken.range[1] = token.range[1];
|
1560 | this.currentToken.loc.end = token.loc.end;
|
1561 | this.currentToken.attributes.push(this.attribute);
|
1562 | return null;
|
1563 | }
|
1564 | HTMLLiteral(token) {
|
1565 | this.tokens.push(token);
|
1566 | if (this.attribute != null) {
|
1567 | this.attribute.range[1] = token.range[1];
|
1568 | this.attribute.loc.end = token.loc.end;
|
1569 | this.attribute.value = {
|
1570 | type: "VLiteral",
|
1571 | range: [token.range[0], token.range[1]],
|
1572 | loc: { start: token.loc.start, end: token.loc.end },
|
1573 | parent: this.attribute,
|
1574 | value: token.value,
|
1575 | };
|
1576 | if (this.currentToken == null ||
|
1577 | this.currentToken.type !== "StartTag") {
|
1578 | throw new Error("unreachable");
|
1579 | }
|
1580 | this.currentToken.range[1] = token.range[1];
|
1581 | this.currentToken.loc.end = token.loc.end;
|
1582 | }
|
1583 | return null;
|
1584 | }
|
1585 | HTMLRCDataText(token) {
|
1586 | return this.processText(token);
|
1587 | }
|
1588 | HTMLRawText(token) {
|
1589 | return this.processText(token);
|
1590 | }
|
1591 | HTMLSelfClosingTagClose(token) {
|
1592 | this.tokens.push(token);
|
1593 | if (this.currentToken == null || this.currentToken.type === "Text") {
|
1594 | throw new Error("unreachable");
|
1595 | }
|
1596 | if (this.currentToken.type === "StartTag") {
|
1597 | this.currentToken.selfClosing = true;
|
1598 | }
|
1599 | else {
|
1600 | this.reportParseError(token, "end-tag-with-trailing-solidus");
|
1601 | }
|
1602 | this.currentToken.range[1] = token.range[1];
|
1603 | this.currentToken.loc.end = token.loc.end;
|
1604 | return this.commit();
|
1605 | }
|
1606 | HTMLTagClose(token) {
|
1607 | this.tokens.push(token);
|
1608 | if (this.currentToken == null || this.currentToken.type === "Text") {
|
1609 | throw new Error("unreachable");
|
1610 | }
|
1611 | this.currentToken.range[1] = token.range[1];
|
1612 | this.currentToken.loc.end = token.loc.end;
|
1613 | return this.commit();
|
1614 | }
|
1615 | HTMLTagOpen(token) {
|
1616 | this.tokens.push(token);
|
1617 | let result = null;
|
1618 | if (this.currentToken != null || this.expressionStartToken != null) {
|
1619 | result = this.commit();
|
1620 | }
|
1621 | this.currentToken = {
|
1622 | type: "StartTag",
|
1623 | range: [token.range[0], token.range[1]],
|
1624 | loc: { start: token.loc.start, end: token.loc.end },
|
1625 | name: token.value,
|
1626 | rawName: this.text.slice(token.range[0] + 1, token.range[1]),
|
1627 | selfClosing: false,
|
1628 | attributes: [],
|
1629 | };
|
1630 | this.attribute = null;
|
1631 | this.attributeNames.clear();
|
1632 | return result;
|
1633 | }
|
1634 | HTMLText(token) {
|
1635 | return this.processText(token);
|
1636 | }
|
1637 | HTMLWhitespace(token) {
|
1638 | return this.processText(token);
|
1639 | }
|
1640 | VExpressionStart(token) {
|
1641 | if (this.expressionStartToken != null) {
|
1642 | return this.processText(token);
|
1643 | }
|
1644 | const separated = this.currentToken != null &&
|
1645 | this.currentToken.range[1] !== token.range[0];
|
1646 | const result = separated ? this.commit() : null;
|
1647 | this.tokens.push(token);
|
1648 | this.expressionStartToken = token;
|
1649 | return result;
|
1650 | }
|
1651 | VExpressionEnd(token) {
|
1652 | if (this.expressionStartToken == null) {
|
1653 | return this.processText(token);
|
1654 | }
|
1655 | const start = this.expressionStartToken;
|
1656 | const end = last(this.expressionTokens) || start;
|
1657 | if (token.range[0] === start.range[1]) {
|
1658 | this.tokens.pop();
|
1659 | this.expressionStartToken = null;
|
1660 | const result = this.processText(start);
|
1661 | this.processText(token);
|
1662 | return result;
|
1663 | }
|
1664 | if (end.range[1] !== token.range[0]) {
|
1665 | const result = this.commit();
|
1666 | this.processText(token);
|
1667 | return result;
|
1668 | }
|
1669 | const value = this.expressionTokens.reduce(concat, "");
|
1670 | this.tokens.push(token);
|
1671 | this.expressionStartToken = null;
|
1672 | this.expressionTokens = [];
|
1673 | const result = this.currentToken != null ? this.commit() : null;
|
1674 | this.currentToken = {
|
1675 | type: "Mustache",
|
1676 | range: [start.range[0], token.range[1]],
|
1677 | loc: { start: start.loc.start, end: token.loc.end },
|
1678 | value,
|
1679 | startToken: start,
|
1680 | endToken: token,
|
1681 | };
|
1682 | return result || this.commit();
|
1683 | }
|
1684 | }
|
1685 |
|
1686 | const DIRECTIVE_NAME = /^(?:v-|[.:@#]).*[^.:@#]$/u;
|
1687 | const DT_DD = /^d[dt]$/u;
|
1688 | const DUMMY_PARENT$2 = Object.freeze({});
|
1689 | function isMathMLIntegrationPoint(element) {
|
1690 | if (element.namespace === NS.MathML) {
|
1691 | const name = element.name;
|
1692 | return (name === "mi" ||
|
1693 | name === "mo" ||
|
1694 | name === "mn" ||
|
1695 | name === "ms" ||
|
1696 | name === "mtext");
|
1697 | }
|
1698 | return false;
|
1699 | }
|
1700 | function isHTMLIntegrationPoint(element) {
|
1701 | if (element.namespace === NS.MathML) {
|
1702 | return (element.name === "annotation-xml" &&
|
1703 | element.startTag.attributes.some(a => a.directive === false &&
|
1704 | a.key.name === "encoding" &&
|
1705 | a.value != null &&
|
1706 | (a.value.value === "text/html" ||
|
1707 | a.value.value === "application/xhtml+xml")));
|
1708 | }
|
1709 | if (element.namespace === NS.SVG) {
|
1710 | const name = element.name;
|
1711 | return name === "foreignObject" || name === "desc" || name === "title";
|
1712 | }
|
1713 | return false;
|
1714 | }
|
1715 | function adjustElementName(name, namespace) {
|
1716 | if (namespace === NS.SVG) {
|
1717 | return SVG_ELEMENT_NAME_MAP.get(name) || name;
|
1718 | }
|
1719 | return name;
|
1720 | }
|
1721 | function adjustAttributeName(name, namespace) {
|
1722 | if (namespace === NS.SVG) {
|
1723 | return SVG_ATTRIBUTE_NAME_MAP.get(name) || name;
|
1724 | }
|
1725 | if (namespace === NS.MathML) {
|
1726 | return MATHML_ATTRIBUTE_NAME_MAP.get(name) || name;
|
1727 | }
|
1728 | return name;
|
1729 | }
|
1730 | function propagateEndLocation(node) {
|
1731 | const lastChild = (node.type === "VElement" ? node.endTag : null) || last(node.children);
|
1732 | if (lastChild != null) {
|
1733 | node.range[1] = lastChild.range[1];
|
1734 | node.loc.end = lastChild.loc.end;
|
1735 | }
|
1736 | }
|
1737 | class Parser {
|
1738 | get text() {
|
1739 | return this.tokenizer.text;
|
1740 | }
|
1741 | get tokens() {
|
1742 | return this.tokenizer.tokens;
|
1743 | }
|
1744 | get comments() {
|
1745 | return this.tokenizer.comments;
|
1746 | }
|
1747 | get errors() {
|
1748 | return this.tokenizer.errors;
|
1749 | }
|
1750 | get namespace() {
|
1751 | return this.tokenizer.namespace;
|
1752 | }
|
1753 | set namespace(value) {
|
1754 | this.tokenizer.namespace = value;
|
1755 | }
|
1756 | get expressionEnabled() {
|
1757 | return this.tokenizer.expressionEnabled;
|
1758 | }
|
1759 | set expressionEnabled(value) {
|
1760 | this.tokenizer.expressionEnabled = value;
|
1761 | }
|
1762 | get currentNode() {
|
1763 | return last(this.elementStack) || this.document;
|
1764 | }
|
1765 | get isInVPreElement() {
|
1766 | return this.vPreElement != null;
|
1767 | }
|
1768 | constructor(tokenizer, parserOptions) {
|
1769 | this.tokenizer = new IntermediateTokenizer(tokenizer);
|
1770 | this.locationCalculator = new LocationCalculator(tokenizer.gaps, tokenizer.lineTerminators);
|
1771 | this.parserOptions = parserOptions;
|
1772 | this.document = {
|
1773 | type: "VDocumentFragment",
|
1774 | range: [0, 0],
|
1775 | loc: {
|
1776 | start: { line: 1, column: 0 },
|
1777 | end: { line: 1, column: 0 },
|
1778 | },
|
1779 | parent: null,
|
1780 | children: [],
|
1781 | tokens: this.tokens,
|
1782 | comments: this.comments,
|
1783 | errors: this.errors,
|
1784 | };
|
1785 | this.elementStack = [];
|
1786 | this.vPreElement = null;
|
1787 | }
|
1788 | parse() {
|
1789 | let token = null;
|
1790 | while ((token = this.tokenizer.nextToken()) != null) {
|
1791 | this[token.type](token);
|
1792 | }
|
1793 | this.popElementStackUntil(0);
|
1794 | propagateEndLocation(this.document);
|
1795 | return this.document;
|
1796 | }
|
1797 | reportParseError(token, code) {
|
1798 | const error = ParseError.fromCode(code, token.range[0], token.loc.start.line, token.loc.start.column);
|
1799 | this.errors.push(error);
|
1800 | debug("[html] syntax error:", error.message);
|
1801 | }
|
1802 | popElementStack() {
|
1803 | assert(this.elementStack.length >= 1);
|
1804 | const element = this.elementStack.pop();
|
1805 | propagateEndLocation(element);
|
1806 | const current = this.currentNode;
|
1807 | this.namespace =
|
1808 | current.type === "VElement" ? current.namespace : NS.HTML;
|
1809 | if (this.vPreElement === element) {
|
1810 | this.vPreElement = null;
|
1811 | this.expressionEnabled = true;
|
1812 | }
|
1813 | if (this.elementStack.length === 0) {
|
1814 | this.expressionEnabled = false;
|
1815 | }
|
1816 | }
|
1817 | popElementStackUntil(index) {
|
1818 | while (this.elementStack.length > index) {
|
1819 | this.popElementStack();
|
1820 | }
|
1821 | }
|
1822 | detectNamespace(token) {
|
1823 | const name = token.name;
|
1824 | let ns = this.namespace;
|
1825 | if (ns === NS.MathML || ns === NS.SVG) {
|
1826 | const element = this.currentNode;
|
1827 | if (element.type === "VElement") {
|
1828 | if (element.namespace === NS.MathML &&
|
1829 | element.name === "annotation-xml" &&
|
1830 | name === "svg") {
|
1831 | return NS.SVG;
|
1832 | }
|
1833 | if (isHTMLIntegrationPoint(element) ||
|
1834 | (isMathMLIntegrationPoint(element) &&
|
1835 | name !== "mglyph" &&
|
1836 | name !== "malignmark")) {
|
1837 | ns = NS.HTML;
|
1838 | }
|
1839 | }
|
1840 | }
|
1841 | if (ns === NS.HTML) {
|
1842 | if (name === "svg") {
|
1843 | return NS.SVG;
|
1844 | }
|
1845 | if (name === "math") {
|
1846 | return NS.MathML;
|
1847 | }
|
1848 | }
|
1849 | if (name === "template") {
|
1850 | const xmlns = token.attributes.find(a => a.key.name === "xmlns");
|
1851 | const value = xmlns && xmlns.value && xmlns.value.value;
|
1852 | if (value === NS.HTML || value === NS.MathML || value === NS.SVG) {
|
1853 | return value;
|
1854 | }
|
1855 | }
|
1856 | return ns;
|
1857 | }
|
1858 | closeCurrentElementIfNecessary(name) {
|
1859 | const element = this.currentNode;
|
1860 | if (element.type !== "VElement") {
|
1861 | return;
|
1862 | }
|
1863 | if (element.name === "p" && HTML_NON_FHRASING_TAGS.has(name)) {
|
1864 | this.popElementStack();
|
1865 | }
|
1866 | if (element.name === name && HTML_CAN_BE_LEFT_OPEN_TAGS.has(name)) {
|
1867 | this.popElementStack();
|
1868 | }
|
1869 | if (DT_DD.test(element.name) && DT_DD.test(name)) {
|
1870 | this.popElementStack();
|
1871 | }
|
1872 | }
|
1873 | processAttribute(node, namespace) {
|
1874 | const tagName = node.parent.parent.name;
|
1875 | const attrName = node.key.name;
|
1876 | if ((this.expressionEnabled ||
|
1877 | (attrName === "v-pre" && !this.isInVPreElement)) &&
|
1878 | (DIRECTIVE_NAME.test(attrName) ||
|
1879 | attrName === "slot-scope" ||
|
1880 | (tagName === "template" && attrName === "scope"))) {
|
1881 | convertToDirective(this.text, this.parserOptions, this.locationCalculator, node);
|
1882 | return;
|
1883 | }
|
1884 | const key = (node.key.name = adjustAttributeName(node.key.name, namespace));
|
1885 | const value = node.value && node.value.value;
|
1886 | if (key === "xmlns" && value !== namespace) {
|
1887 | this.reportParseError(node, "x-invalid-namespace");
|
1888 | }
|
1889 | else if (key === "xmlns:xlink" && value !== NS.XLink) {
|
1890 | this.reportParseError(node, "x-invalid-namespace");
|
1891 | }
|
1892 | }
|
1893 | StartTag(token) {
|
1894 | debug("[html] StartTag %j", token);
|
1895 | this.closeCurrentElementIfNecessary(token.name);
|
1896 | const parent = this.currentNode;
|
1897 | const namespace = this.detectNamespace(token);
|
1898 | const element = {
|
1899 | type: "VElement",
|
1900 | range: [token.range[0], token.range[1]],
|
1901 | loc: { start: token.loc.start, end: token.loc.end },
|
1902 | parent,
|
1903 | name: adjustElementName(token.name, namespace),
|
1904 | rawName: token.rawName,
|
1905 | namespace,
|
1906 | startTag: {
|
1907 | type: "VStartTag",
|
1908 | range: token.range,
|
1909 | loc: token.loc,
|
1910 | parent: DUMMY_PARENT$2,
|
1911 | selfClosing: token.selfClosing,
|
1912 | attributes: token.attributes,
|
1913 | },
|
1914 | children: [],
|
1915 | endTag: null,
|
1916 | variables: [],
|
1917 | };
|
1918 | const hasVPre = !this.isInVPreElement &&
|
1919 | token.attributes.some(a => a.key.name === "v-pre");
|
1920 | if (hasVPre) {
|
1921 | this.expressionEnabled = false;
|
1922 | }
|
1923 | parent.children.push(element);
|
1924 | element.startTag.parent = element;
|
1925 | for (const attribute of token.attributes) {
|
1926 | attribute.parent = element.startTag;
|
1927 | this.processAttribute(attribute, namespace);
|
1928 | }
|
1929 | for (const attribute of element.startTag.attributes) {
|
1930 | if (attribute.directive) {
|
1931 | if (attribute.key.argument != null &&
|
1932 | attribute.key.argument.type === "VExpressionContainer") {
|
1933 | resolveReferences(attribute.key.argument);
|
1934 | }
|
1935 | if (attribute.value != null) {
|
1936 | resolveReferences(attribute.value);
|
1937 | }
|
1938 | }
|
1939 | }
|
1940 | const isVoid = namespace === NS.HTML && HTML_VOID_ELEMENT_TAGS.has(element.name);
|
1941 | if (token.selfClosing && !isVoid && namespace === NS.HTML) {
|
1942 | this.reportParseError(token, "non-void-html-element-start-tag-with-trailing-solidus");
|
1943 | }
|
1944 | if (token.selfClosing || isVoid) {
|
1945 | this.expressionEnabled = !this.isInVPreElement;
|
1946 | return;
|
1947 | }
|
1948 | this.elementStack.push(element);
|
1949 | if (hasVPre) {
|
1950 | assert(this.vPreElement === null);
|
1951 | this.vPreElement = element;
|
1952 | }
|
1953 | this.namespace = namespace;
|
1954 | if (namespace === NS.HTML) {
|
1955 | if (element.name === "template" &&
|
1956 | element.parent.type === "VDocumentFragment") {
|
1957 | const langAttr = element.startTag.attributes.find(a => !a.directive && a.key.name === "lang");
|
1958 | const lang = (langAttr && langAttr.value && langAttr.value.value) ||
|
1959 | "html";
|
1960 | if (lang !== "html") {
|
1961 | this.tokenizer.state = "RAWTEXT";
|
1962 | }
|
1963 | this.expressionEnabled = true;
|
1964 | }
|
1965 | if (HTML_RCDATA_TAGS.has(element.name)) {
|
1966 | this.tokenizer.state = "RCDATA";
|
1967 | }
|
1968 | if (HTML_RAWTEXT_TAGS.has(element.name)) {
|
1969 | this.tokenizer.state = "RAWTEXT";
|
1970 | }
|
1971 | }
|
1972 | }
|
1973 | EndTag(token) {
|
1974 | debug("[html] EndTag %j", token);
|
1975 | const i = findLastIndex(this.elementStack, el => el.name.toLowerCase() === token.name);
|
1976 | if (i === -1) {
|
1977 | this.reportParseError(token, "x-invalid-end-tag");
|
1978 | return;
|
1979 | }
|
1980 | const element = this.elementStack[i];
|
1981 | element.endTag = {
|
1982 | type: "VEndTag",
|
1983 | range: token.range,
|
1984 | loc: token.loc,
|
1985 | parent: element,
|
1986 | };
|
1987 | this.popElementStackUntil(i);
|
1988 | }
|
1989 | Text(token) {
|
1990 | debug("[html] Text %j", token);
|
1991 | const parent = this.currentNode;
|
1992 | parent.children.push({
|
1993 | type: "VText",
|
1994 | range: token.range,
|
1995 | loc: token.loc,
|
1996 | parent,
|
1997 | value: token.value,
|
1998 | });
|
1999 | }
|
2000 | Mustache(token) {
|
2001 | debug("[html] Mustache %j", token);
|
2002 | const parent = this.currentNode;
|
2003 | const container = {
|
2004 | type: "VExpressionContainer",
|
2005 | range: token.range,
|
2006 | loc: token.loc,
|
2007 | parent,
|
2008 | expression: null,
|
2009 | references: [],
|
2010 | };
|
2011 | processMustache(this.parserOptions, this.locationCalculator, container, token);
|
2012 | parent.children.push(container);
|
2013 | resolveReferences(container);
|
2014 | }
|
2015 | }
|
2016 |
|
2017 | const alternativeCR = new Map([[128, 8364], [130, 8218], [131, 402], [132, 8222], [133, 8230], [134, 8224], [135, 8225], [136, 710], [137, 8240], [138, 352], [139, 8249], [140, 338], [142, 381], [145, 8216], [146, 8217], [147, 8220], [148, 8221], [149, 8226], [150, 8211], [151, 8212], [152, 732], [153, 8482], [154, 353], [155, 8250], [156, 339], [158, 382], [159, 376]]);
|
2018 |
|
2019 | const entitySets = [{ "length": 32, "entities": { "CounterClockwiseContourIntegral;": [8755] } }, { "length": 25, "entities": { "ClockwiseContourIntegral;": [8754], "DoubleLongLeftRightArrow;": [10234] } }, { "length": 24, "entities": { "NotNestedGreaterGreater;": [10914, 824] } }, { "length": 23, "entities": { "DiacriticalDoubleAcute;": [733], "NotSquareSupersetEqual;": [8931] } }, { "length": 22, "entities": { "CloseCurlyDoubleQuote;": [8221], "DoubleContourIntegral;": [8751], "FilledVerySmallSquare;": [9642], "NegativeVeryThinSpace;": [8203], "NotPrecedesSlantEqual;": [8928], "NotRightTriangleEqual;": [8941], "NotSucceedsSlantEqual;": [8929] } }, { "length": 21, "entities": { "CapitalDifferentialD;": [8517], "DoubleLeftRightArrow;": [8660], "DoubleLongRightArrow;": [10233], "EmptyVerySmallSquare;": [9643], "NestedGreaterGreater;": [8811], "NotDoubleVerticalBar;": [8742], "NotGreaterSlantEqual;": [10878, 824], "NotLeftTriangleEqual;": [8940], "NotSquareSubsetEqual;": [8930], "OpenCurlyDoubleQuote;": [8220], "ReverseUpEquilibrium;": [10607] } }, { "length": 20, "entities": { "DoubleLongLeftArrow;": [10232], "DownLeftRightVector;": [10576], "LeftArrowRightArrow;": [8646], "NegativeMediumSpace;": [8203], "NotGreaterFullEqual;": [8807, 824], "NotRightTriangleBar;": [10704, 824], "RightArrowLeftArrow;": [8644], "SquareSupersetEqual;": [8850], "leftrightsquigarrow;": [8621] } }, { "length": 19, "entities": { "DownRightTeeVector;": [10591], "DownRightVectorBar;": [10583], "LongLeftRightArrow;": [10231], "Longleftrightarrow;": [10234], "NegativeThickSpace;": [8203], "NotLeftTriangleBar;": [10703, 824], "PrecedesSlantEqual;": [8828], "ReverseEquilibrium;": [8651], "RightDoubleBracket;": [10215], "RightDownTeeVector;": [10589], "RightDownVectorBar;": [10581], "RightTriangleEqual;": [8885], "SquareIntersection;": [8851], "SucceedsSlantEqual;": [8829], "blacktriangleright;": [9656], "longleftrightarrow;": [10231] } }, { "length": 18, "entities": { "DoubleUpDownArrow;": [8661], "DoubleVerticalBar;": [8741], "DownLeftTeeVector;": [10590], "DownLeftVectorBar;": [10582], "FilledSmallSquare;": [9724], "GreaterSlantEqual;": [10878], "LeftDoubleBracket;": [10214], "LeftDownTeeVector;": [10593], "LeftDownVectorBar;": [10585], "LeftTriangleEqual;": [8884], "NegativeThinSpace;": [8203], "NotGreaterGreater;": [8811, 824], "NotLessSlantEqual;": [10877, 824], "NotNestedLessLess;": [10913, 824], "NotReverseElement;": [8716], "NotSquareSuperset;": [8848, 824], "NotTildeFullEqual;": [8775], "RightAngleBracket;": [10217], "RightUpDownVector;": [10575], "SquareSubsetEqual;": [8849], "VerticalSeparator;": [10072], "blacktriangledown;": [9662], "blacktriangleleft;": [9666], "leftrightharpoons;": [8651], "rightleftharpoons;": [8652], "twoheadrightarrow;": [8608] } }, { "length": 17, "entities": { "DiacriticalAcute;": [180], "DiacriticalGrave;": [96], "DiacriticalTilde;": [732], "DoubleRightArrow;": [8658], "DownArrowUpArrow;": [8693], "EmptySmallSquare;": [9723], "GreaterEqualLess;": [8923], "GreaterFullEqual;": [8807], "LeftAngleBracket;": [10216], "LeftUpDownVector;": [10577], "LessEqualGreater;": [8922], "NonBreakingSpace;": [160], "NotPrecedesEqual;": [10927, 824], "NotRightTriangle;": [8939], "NotSucceedsEqual;": [10928, 824], "NotSucceedsTilde;": [8831, 824], "NotSupersetEqual;": [8841], "RightTriangleBar;": [10704], "RightUpTeeVector;": [10588], "RightUpVectorBar;": [10580], "UnderParenthesis;": [9181], "UpArrowDownArrow;": [8645], "circlearrowright;": [8635], "downharpoonright;": [8642], "ntrianglerighteq;": [8941], "rightharpoondown;": [8641], "rightrightarrows;": [8649], "twoheadleftarrow;": [8606], "vartriangleright;": [8883] } }, { "length": 16, "entities": { "CloseCurlyQuote;": [8217], "ContourIntegral;": [8750], "DoubleDownArrow;": [8659], "DoubleLeftArrow;": [8656], "DownRightVector;": [8641], "LeftRightVector;": [10574], "LeftTriangleBar;": [10703], "LeftUpTeeVector;": [10592], "LeftUpVectorBar;": [10584], "LowerRightArrow;": [8600], "NotGreaterEqual;": [8817], "NotGreaterTilde;": [8821], "NotHumpDownHump;": [8782, 824], "NotLeftTriangle;": [8938], "NotSquareSubset;": [8847, 824], "OverParenthesis;": [9180], "RightDownVector;": [8642], "ShortRightArrow;": [8594], "UpperRightArrow;": [8599], "bigtriangledown;": [9661], "circlearrowleft;": [8634], "curvearrowright;": [8631], "downharpoonleft;": [8643], "leftharpoondown;": [8637], "leftrightarrows;": [8646], "nLeftrightarrow;": [8654], "nleftrightarrow;": [8622], "ntrianglelefteq;": [8940], "rightleftarrows;": [8644], "rightsquigarrow;": [8605], "rightthreetimes;": [8908], "straightepsilon;": [1013], "trianglerighteq;": [8885], "vartriangleleft;": [8882] } }, { "length": 15, "entities": { "DiacriticalDot;": [729], "DoubleRightTee;": [8872], "DownLeftVector;": [8637], "GreaterGreater;": [10914], "HorizontalLine;": [9472], "InvisibleComma;": [8291], "InvisibleTimes;": [8290], "LeftDownVector;": [8643], "LeftRightArrow;": [8596], "Leftrightarrow;": [8660], "LessSlantEqual;": [10877], "LongRightArrow;": [10230], "Longrightarrow;": [10233], "LowerLeftArrow;": [8601], "NestedLessLess;": [8810], "NotGreaterLess;": [8825], "NotLessGreater;": [8824], "NotSubsetEqual;": [8840], "NotVerticalBar;": [8740], "OpenCurlyQuote;": [8216], "ReverseElement;": [8715], "RightTeeVector;": [10587], "RightVectorBar;": [10579], "ShortDownArrow;": [8595], "ShortLeftArrow;": [8592], "SquareSuperset;": [8848], "TildeFullEqual;": [8773], "UpperLeftArrow;": [8598], "ZeroWidthSpace;": [8203], "curvearrowleft;": [8630], "doublebarwedge;": [8966], "downdownarrows;": [8650], "hookrightarrow;": [8618], "leftleftarrows;": [8647], "leftrightarrow;": [8596], "leftthreetimes;": [8907], "longrightarrow;": [10230], "looparrowright;": [8620], "nshortparallel;": [8742], "ntriangleright;": [8939], "rightarrowtail;": [8611], "rightharpoonup;": [8640], "trianglelefteq;": [8884], "upharpoonright;": [8638] } }, { "length": 14, "entities": { "ApplyFunction;": [8289], "DifferentialD;": [8518], "DoubleLeftTee;": [10980], "DoubleUpArrow;": [8657], "LeftTeeVector;": [10586], "LeftVectorBar;": [10578], "LessFullEqual;": [8806], "LongLeftArrow;": [10229], "Longleftarrow;": [10232], "NotEqualTilde;": [8770, 824], "NotTildeEqual;": [8772], "NotTildeTilde;": [8777], "Poincareplane;": [8460], "PrecedesEqual;": [10927], "PrecedesTilde;": [8830], "RightArrowBar;": [8677], "RightTeeArrow;": [8614], "RightTriangle;": [8883], "RightUpVector;": [8638], "SucceedsEqual;": [10928], "SucceedsTilde;": [8831], "SupersetEqual;": [8839], "UpEquilibrium;": [10606], "VerticalTilde;": [8768], "VeryThinSpace;": [8202], "bigtriangleup;": [9651], "blacktriangle;": [9652], "divideontimes;": [8903], "fallingdotseq;": [8786], "hookleftarrow;": [8617], "leftarrowtail;": [8610], "leftharpoonup;": [8636], "longleftarrow;": [10229], "looparrowleft;": [8619], "measuredangle;": [8737], "ntriangleleft;": [8938], "shortparallel;": [8741], "smallsetminus;": [8726], "triangleright;": [9657], "upharpoonleft;": [8639], "varsubsetneqq;": [10955, 65024], "varsupsetneqq;": [10956, 65024] } }, { "length": 13, "entities": { "DownArrowBar;": [10515], "DownTeeArrow;": [8615], "ExponentialE;": [8519], "GreaterEqual;": [8805], "GreaterTilde;": [8819], "HilbertSpace;": [8459], "HumpDownHump;": [8782], "Intersection;": [8898], "LeftArrowBar;": [8676], "LeftTeeArrow;": [8612], "LeftTriangle;": [8882], "LeftUpVector;": [8639], "NotCongruent;": [8802], "NotHumpEqual;": [8783, 824], "NotLessEqual;": [8816], "NotLessTilde;": [8820], "Proportional;": [8733], "RightCeiling;": [8969], "RoundImplies;": [10608], "ShortUpArrow;": [8593], "SquareSubset;": [8847], "UnderBracket;": [9141], "VerticalLine;": [124], "blacklozenge;": [10731], "exponentiale;": [8519], "risingdotseq;": [8787], "triangledown;": [9663], "triangleleft;": [9667], "varsubsetneq;": [8842, 65024], "varsupsetneq;": [8843, 65024] } }, { "length": 12, "entities": { "CircleMinus;": [8854], "CircleTimes;": [8855], "Equilibrium;": [8652], "GreaterLess;": [8823], "LeftCeiling;": [8968], "LessGreater;": [8822], "MediumSpace;": [8287], "NotLessLess;": [8810, 824], "NotPrecedes;": [8832], "NotSucceeds;": [8833], "NotSuperset;": [8835, 8402], "OverBracket;": [9140], "RightVector;": [8640], "Rrightarrow;": [8667], "RuleDelayed;": [10740], "SmallCircle;": [8728], "SquareUnion;": [8852], "SubsetEqual;": [8838], "UpDownArrow;": [8597], "Updownarrow;": [8661], "VerticalBar;": [8739], "backepsilon;": [1014], "blacksquare;": [9642], "circledcirc;": [8858], "circleddash;": [8861], "curlyeqprec;": [8926], "curlyeqsucc;": [8927], "diamondsuit;": [9830], "eqslantless;": [10901], "expectation;": [8496], "nRightarrow;": [8655], "nrightarrow;": [8603], "preccurlyeq;": [8828], "precnapprox;": [10937], "quaternions;": [8461], "straightphi;": [981], "succcurlyeq;": [8829], "succnapprox;": [10938], "thickapprox;": [8776], "updownarrow;": [8597] } }, { "length": 11, "entities": { "Bernoullis;": [8492], "CirclePlus;": [8853], "EqualTilde;": [8770], "Fouriertrf;": [8497], "ImaginaryI;": [8520], "Laplacetrf;": [8466], "LeftVector;": [8636], "Lleftarrow;": [8666], "NotElement;": [8713], "NotGreater;": [8815], "Proportion;": [8759], "RightArrow;": [8594], "RightFloor;": [8971], "Rightarrow;": [8658], "ThickSpace;": [8287, 8202], "TildeEqual;": [8771], "TildeTilde;": [8776], "UnderBrace;": [9183], "UpArrowBar;": [10514], "UpTeeArrow;": [8613], "circledast;": [8859], "complement;": [8705], "curlywedge;": [8911], "eqslantgtr;": [10902], "gtreqqless;": [10892], "lessapprox;": [10885], "lesseqqgtr;": [10891], "lmoustache;": [9136], "longmapsto;": [10236], "mapstodown;": [8615], "mapstoleft;": [8612], "nLeftarrow;": [8653], "nleftarrow;": [8602], "nsubseteqq;": [10949, 824], "nsupseteqq;": [10950, 824], "precapprox;": [10935], "rightarrow;": [8594], "rmoustache;": [9137], "sqsubseteq;": [8849], "sqsupseteq;": [8850], "subsetneqq;": [10955], "succapprox;": [10936], "supsetneqq;": [10956], "upuparrows;": [8648], "varepsilon;": [1013], "varnothing;": [8709] } }, { "length": 10, "entities": { "Backslash;": [8726], "CenterDot;": [183], "CircleDot;": [8857], "Congruent;": [8801], "Coproduct;": [8720], "DoubleDot;": [168], "DownArrow;": [8595], "DownBreve;": [785], "Downarrow;": [8659], "HumpEqual;": [8783], "LeftArrow;": [8592], "LeftFloor;": [8970], "Leftarrow;": [8656], "LessTilde;": [8818], "Mellintrf;": [8499], "MinusPlus;": [8723], "NotCupCap;": [8813], "NotExists;": [8708], "NotSubset;": [8834, 8402], "OverBrace;": [9182], "PlusMinus;": [177], "Therefore;": [8756], "ThinSpace;": [8201], "TripleDot;": [8411], "UnionPlus;": [8846], "backprime;": [8245], "backsimeq;": [8909], "bigotimes;": [10754], "centerdot;": [183], "checkmark;": [10003], "complexes;": [8450], "dotsquare;": [8865], "downarrow;": [8595], "gtrapprox;": [10886], "gtreqless;": [8923], "gvertneqq;": [8809, 65024], "heartsuit;": [9829], "leftarrow;": [8592], "lesseqgtr;": [8922], "lvertneqq;": [8808, 65024], "ngeqslant;": [10878, 824], "nleqslant;": [10877, 824], "nparallel;": [8742], "nshortmid;": [8740], "nsubseteq;": [8840], "nsupseteq;": [8841], "pitchfork;": [8916], "rationals;": [8474], "spadesuit;": [9824], "subseteqq;": [10949], "subsetneq;": [8842], "supseteqq;": [10950], "supsetneq;": [8843], "therefore;": [8756], "triangleq;": [8796], "varpropto;": [8733] } }, { "length": 9, "entities": { "DDotrahd;": [10513], "DotEqual;": [8784], "Integral;": [8747], "LessLess;": [10913], "NotEqual;": [8800], "NotTilde;": [8769], "PartialD;": [8706], "Precedes;": [8826], "RightTee;": [8866], "Succeeds;": [8827], "SuchThat;": [8715], "Superset;": [8835], "Uarrocir;": [10569], "UnderBar;": [95], "andslope;": [10840], "angmsdaa;": [10664], "angmsdab;": [10665], "angmsdac;": [10666], "angmsdad;": [10667], "angmsdae;": [10668], "angmsdaf;": [10669], "angmsdag;": [10670], "angmsdah;": [10671], "angrtvbd;": [10653], "approxeq;": [8778], "awconint;": [8755], "backcong;": [8780], "barwedge;": [8965], "bbrktbrk;": [9142], "bigoplus;": [10753], "bigsqcup;": [10758], "biguplus;": [10756], "bigwedge;": [8896], "boxminus;": [8863], "boxtimes;": [8864], "bsolhsub;": [10184], "capbrcup;": [10825], "circledR;": [174], "circledS;": [9416], "cirfnint;": [10768], "clubsuit;": [9827], "cupbrcap;": [10824], "curlyvee;": [8910], "cwconint;": [8754], "doteqdot;": [8785], "dotminus;": [8760], "drbkarow;": [10512], "dzigrarr;": [10239], "elinters;": [9191], "emptyset;": [8709], "eqvparsl;": [10725], "fpartint;": [10765], "geqslant;": [10878], "gesdotol;": [10884], "gnapprox;": [10890], "hksearow;": [10533], "hkswarow;": [10534], "imagline;": [8464], "imagpart;": [8465], "infintie;": [10717], "integers;": [8484], "intercal;": [8890], "intlarhk;": [10775], "laemptyv;": [10676], "ldrushar;": [10571], "leqslant;": [10877], "lesdotor;": [10883], "llcorner;": [8990], "lnapprox;": [10889], "lrcorner;": [8991], "lurdshar;": [10570], "mapstoup;": [8613], "multimap;": [8888], "naturals;": [8469], "ncongdot;": [10861, 824], "notindot;": [8949, 824], "otimesas;": [10806], "parallel;": [8741], "plusacir;": [10787], "pointint;": [10773], "precneqq;": [10933], "precnsim;": [8936], "profalar;": [9006], "profline;": [8978], "profsurf;": [8979], "raemptyv;": [10675], "realpart;": [8476], "rppolint;": [10770], "rtriltri;": [10702], "scpolint;": [10771], "setminus;": [8726], "shortmid;": [8739], "smeparsl;": [10724], "sqsubset;": [8847], "sqsupset;": [8848], "subseteq;": [8838], "succneqq;": [10934], "succnsim;": [8937], "supseteq;": [8839], "thetasym;": [977], "thicksim;": [8764], "timesbar;": [10801], "triangle;": [9653], "triminus;": [10810], "trpezium;": [9186], "ulcorner;": [8988], "urcorner;": [8989], "varkappa;": [1008], "varsigma;": [962], "vartheta;": [977] } }, { "length": 8, "entities": { "Because;": [8757], "Cayleys;": [8493], "Cconint;": [8752], "Cedilla;": [184], "Diamond;": [8900], "DownTee;": [8868], "Element;": [8712], "Epsilon;": [917], "Implies;": [8658], "LeftTee;": [8867], "NewLine;": [10], "NoBreak;": [8288], "NotLess;": [8814], "Omicron;": [927], "OverBar;": [8254], "Product;": [8719], "UpArrow;": [8593], "Uparrow;": [8657], "Upsilon;": [933], "alefsym;": [8501], "angrtvb;": [8894], "angzarr;": [9084], "asympeq;": [8781], "backsim;": [8765], "because;": [8757], "bemptyv;": [10672], "between;": [8812], "bigcirc;": [9711], "bigodot;": [10752], "bigstar;": [9733], "bnequiv;": [8801, 8421], "boxplus;": [8862], "ccupssm;": [10832], "cemptyv;": [10674], "cirscir;": [10690], "coloneq;": [8788], "congdot;": [10861], "cudarrl;": [10552], "cudarrr;": [10549], "cularrp;": [10557], "curarrm;": [10556], "dbkarow;": [10511], "ddagger;": [8225], "ddotseq;": [10871], "demptyv;": [10673], "diamond;": [8900], "digamma;": [989], "dotplus;": [8724], "dwangle;": [10662], "epsilon;": [949], "eqcolon;": [8789], "equivDD;": [10872], "gesdoto;": [10882], "gtquest;": [10876], "gtrless;": [8823], "harrcir;": [10568], "intprod;": [10812], "isindot;": [8949], "larrbfs;": [10527], "larrsim;": [10611], "lbrksld;": [10639], "lbrkslu;": [10637], "ldrdhar;": [10599], "lesdoto;": [10881], "lessdot;": [8918], "lessgtr;": [8822], "lesssim;": [8818], "lotimes;": [10804], "lozenge;": [9674], "ltquest;": [10875], "luruhar;": [10598], "maltese;": [10016], "minusdu;": [10794], "napprox;": [8777], "natural;": [9838], "nearrow;": [8599], "nexists;": [8708], "notinva;": [8713], "notinvb;": [8951], "notinvc;": [8950], "notniva;": [8716], "notnivb;": [8958], "notnivc;": [8957], "npolint;": [10772], "npreceq;": [10927, 824], "nsqsube;": [8930], "nsqsupe;": [8931], "nsubset;": [8834, 8402], "nsucceq;": [10928, 824], "nsupset;": [8835, 8402], "nvinfin;": [10718], "nvltrie;": [8884, 8402], "nvrtrie;": [8885, 8402], "nwarrow;": [8598], "olcross;": [10683], "omicron;": [959], "orderof;": [8500], "orslope;": [10839], "pertenk;": [8241], "planckh;": [8462], "pluscir;": [10786], "plussim;": [10790], "plustwo;": [10791], "precsim;": [8830], "quatint;": [10774], "questeq;": [8799], "rarrbfs;": [10528], "rarrsim;": [10612], "rbrksld;": [10638], "rbrkslu;": [10640], "rdldhar;": [10601], "realine;": [8475], "rotimes;": [10805], "ruluhar;": [10600], "searrow;": [8600], "simplus;": [10788], "simrarr;": [10610], "subedot;": [10947], "submult;": [10945], "subplus;": [10943], "subrarr;": [10617], "succsim;": [8831], "supdsub;": [10968], "supedot;": [10948], "suphsol;": [10185], "suphsub;": [10967], "suplarr;": [10619], "supmult;": [10946], "supplus;": [10944], "swarrow;": [8601], "topfork;": [10970], "triplus;": [10809], "tritime;": [10811], "uparrow;": [8593], "upsilon;": [965], "uwangle;": [10663], "vzigzag;": [10650], "zigrarr;": [8669] } }, { "length": 7, "entities": { "Aacute;": [193], "Abreve;": [258], "Agrave;": [192], "Assign;": [8788], "Atilde;": [195], "Barwed;": [8966], "Bumpeq;": [8782], "Cacute;": [262], "Ccaron;": [268], "Ccedil;": [199], "Colone;": [10868], "Conint;": [8751], "CupCap;": [8781], "Dagger;": [8225], "Dcaron;": [270], "DotDot;": [8412], "Dstrok;": [272], "Eacute;": [201], "Ecaron;": [282], "Egrave;": [200], "Exists;": [8707], "ForAll;": [8704], "Gammad;": [988], "Gbreve;": [286], "Gcedil;": [290], "HARDcy;": [1066], "Hstrok;": [294], "Iacute;": [205], "Igrave;": [204], "Itilde;": [296], "Jsercy;": [1032], "Kcedil;": [310], "Lacute;": [313], "Lambda;": [923], "Lcaron;": [317], "Lcedil;": [315], "Lmidot;": [319], "Lstrok;": [321], "Nacute;": [323], "Ncaron;": [327], "Ncedil;": [325], "Ntilde;": [209], "Oacute;": [211], "Odblac;": [336], "Ograve;": [210], "Oslash;": [216], "Otilde;": [213], "Otimes;": [10807], "Racute;": [340], "Rarrtl;": [10518], "Rcaron;": [344], "Rcedil;": [342], "SHCHcy;": [1065], "SOFTcy;": [1068], "Sacute;": [346], "Scaron;": [352], "Scedil;": [350], "Square;": [9633], "Subset;": [8912], "Supset;": [8913], "Tcaron;": [356], "Tcedil;": [354], "Tstrok;": [358], "Uacute;": [218], "Ubreve;": [364], "Udblac;": [368], "Ugrave;": [217], "Utilde;": [360], "Vdashl;": [10982], "Verbar;": [8214], "Vvdash;": [8874], "Yacute;": [221], "Zacute;": [377], "Zcaron;": [381], "aacute;": [225], "abreve;": [259], "agrave;": [224], "andand;": [10837], "angmsd;": [8737], "angsph;": [8738], "apacir;": [10863], "approx;": [8776], "atilde;": [227], "barvee;": [8893], "barwed;": [8965], "becaus;": [8757], "bernou;": [8492], "bigcap;": [8898], "bigcup;": [8899], "bigvee;": [8897], "bkarow;": [10509], "bottom;": [8869], "bowtie;": [8904], "boxbox;": [10697], "bprime;": [8245], "brvbar;": [166], "bullet;": [8226], "bumpeq;": [8783], "cacute;": [263], "capand;": [10820], "capcap;": [10827], "capcup;": [10823], "capdot;": [10816], "ccaron;": [269], "ccedil;": [231], "circeq;": [8791], "cirmid;": [10991], "colone;": [8788], "commat;": [64], "compfn;": [8728], "conint;": [8750], "coprod;": [8720], "copysr;": [8471], "cularr;": [8630], "cupcap;": [10822], "cupcup;": [10826], "cupdot;": [8845], "curarr;": [8631], "curren;": [164], "cylcty;": [9005], "dagger;": [8224], "daleth;": [8504], "dcaron;": [271], "dfisht;": [10623], "divide;": [247], "divonx;": [8903], "dlcorn;": [8990], "dlcrop;": [8973], "dollar;": [36], "drcorn;": [8991], "drcrop;": [8972], "dstrok;": [273], "eacute;": [233], "easter;": [10862], "ecaron;": [283], "ecolon;": [8789], "egrave;": [232], "egsdot;": [10904], "elsdot;": [10903], "emptyv;": [8709], "emsp13;": [8196], "emsp14;": [8197], "eparsl;": [10723], "eqcirc;": [8790], "equals;": [61], "equest;": [8799], "female;": [9792], "ffilig;": [64259], "ffllig;": [64260], "forall;": [8704], "frac12;": [189], "frac13;": [8531], "frac14;": [188], "frac15;": [8533], "frac16;": [8537], "frac18;": [8539], "frac23;": [8532], "frac25;": [8534], "frac34;": [190], "frac35;": [8535], "frac38;": [8540], "frac45;": [8536], "frac56;": [8538], "frac58;": [8541], "frac78;": [8542], "gacute;": [501], "gammad;": [989], "gbreve;": [287], "gesdot;": [10880], "gesles;": [10900], "gtlPar;": [10645], "gtrarr;": [10616], "gtrdot;": [8919], "gtrsim;": [8819], "hairsp;": [8202], "hamilt;": [8459], "hardcy;": [1098], "hearts;": [9829], "hellip;": [8230], "hercon;": [8889], "homtht;": [8763], "horbar;": [8213], "hslash;": [8463], "hstrok;": [295], "hybull;": [8259], "hyphen;": [8208], "iacute;": [237], "igrave;": [236], "iiiint;": [10764], "iinfin;": [10716], "incare;": [8453], "inodot;": [305], "intcal;": [8890], "iquest;": [191], "isinsv;": [8947], "itilde;": [297], "jsercy;": [1112], "kappav;": [1008], "kcedil;": [311], "kgreen;": [312], "lAtail;": [10523], "lacute;": [314], "lagran;": [8466], "lambda;": [955], "langle;": [10216], "larrfs;": [10525], "larrhk;": [8617], "larrlp;": [8619], "larrpl;": [10553], "larrtl;": [8610], "latail;": [10521], "lbrace;": [123], "lbrack;": [91], "lcaron;": [318], "lcedil;": [316], "ldquor;": [8222], "lesdot;": [10879], "lesges;": [10899], "lfisht;": [10620], "lfloor;": [8970], "lharul;": [10602], "llhard;": [10603], "lmidot;": [320], "lmoust;": [9136], "loplus;": [10797], "lowast;": [8727], "lowbar;": [95], "lparlt;": [10643], "lrhard;": [10605], "lsaquo;": [8249], "lsquor;": [8218], "lstrok;": [322], "lthree;": [8907], "ltimes;": [8905], "ltlarr;": [10614], "ltrPar;": [10646], "mapsto;": [8614], "marker;": [9646], "mcomma;": [10793], "midast;": [42], "midcir;": [10992], "middot;": [183], "minusb;": [8863], "minusd;": [8760], "mnplus;": [8723], "models;": [8871], "mstpos;": [8766], "nVDash;": [8879], "nVdash;": [8878], "nacute;": [324], "nbumpe;": [8783, 824], "ncaron;": [328], "ncedil;": [326], "nearhk;": [10532], "nequiv;": [8802], "nesear;": [10536], "nexist;": [8708], "nltrie;": [8940], "notinE;": [8953, 824], "nparsl;": [11005, 8421], "nprcue;": [8928], "nrarrc;": [10547, 824], "nrarrw;": [8605, 824], "nrtrie;": [8941], "nsccue;": [8929], "nsimeq;": [8772], "ntilde;": [241], "numero;": [8470], "nvDash;": [8877], "nvHarr;": [10500], "nvdash;": [8876], "nvlArr;": [10498], "nvrArr;": [10499], "nwarhk;": [10531], "nwnear;": [10535], "oacute;": [243], "odblac;": [337], "odsold;": [10684], "ograve;": [242], "ominus;": [8854], "origof;": [8886], "oslash;": [248], "otilde;": [245], "otimes;": [8855], "parsim;": [10995], "percnt;": [37], "period;": [46], "permil;": [8240], "phmmat;": [8499], "planck;": [8463], "plankv;": [8463], "plusdo;": [8724], "plusdu;": [10789], "plusmn;": [177], "preceq;": [10927], "primes;": [8473], "prnsim;": [8936], "propto;": [8733], "prurel;": [8880], "puncsp;": [8200], "qprime;": [8279], "rAtail;": [10524], "racute;": [341], "rangle;": [10217], "rarrap;": [10613], "rarrfs;": [10526], "rarrhk;": [8618], "rarrlp;": [8620], "rarrpl;": [10565], "rarrtl;": [8611], "ratail;": [10522], "rbrace;": [125], "rbrack;": [93], "rcaron;": [345], "rcedil;": [343], "rdquor;": [8221], "rfisht;": [10621], "rfloor;": [8971], "rharul;": [10604], "rmoust;": [9137], "roplus;": [10798], "rpargt;": [10644], "rsaquo;": [8250], "rsquor;": [8217], "rthree;": [8908], "rtimes;": [8906], "sacute;": [347], "scaron;": [353], "scedil;": [351], "scnsim;": [8937], "searhk;": [10533], "seswar;": [10537], "sfrown;": [8994], "shchcy;": [1097], "sigmaf;": [962], "sigmav;": [962], "simdot;": [10858], "smashp;": [10803], "softcy;": [1100], "solbar;": [9023], "spades;": [9824], "sqcaps;": [8851, 65024], "sqcups;": [8852, 65024], "sqsube;": [8849], "sqsupe;": [8850], "square;": [9633], "squarf;": [9642], "ssetmn;": [8726], "ssmile;": [8995], "sstarf;": [8902], "subdot;": [10941], "subset;": [8834], "subsim;": [10951], "subsub;": [10965], "subsup;": [10963], "succeq;": [10928], "supdot;": [10942], "supset;": [8835], "supsim;": [10952], "supsub;": [10964], "supsup;": [10966], "swarhk;": [10534], "swnwar;": [10538], "target;": [8982], "tcaron;": [357], "tcedil;": [355], "telrec;": [8981], "there4;": [8756], "thetav;": [977], "thinsp;": [8201], "thksim;": [8764], "timesb;": [8864], "timesd;": [10800], "topbot;": [9014], "topcir;": [10993], "tprime;": [8244], "tridot;": [9708], "tstrok;": [359], "uacute;": [250], "ubreve;": [365], "udblac;": [369], "ufisht;": [10622], "ugrave;": [249], "ulcorn;": [8988], "ulcrop;": [8975], "urcorn;": [8989], "urcrop;": [8974], "utilde;": [361], "vangrt;": [10652], "varphi;": [981], "varrho;": [1009], "veebar;": [8891], "vellip;": [8942], "verbar;": [124], "vsubnE;": [10955, 65024], "vsubne;": [8842, 65024], "vsupnE;": [10956, 65024], "vsupne;": [8843, 65024], "wedbar;": [10847], "wedgeq;": [8793], "weierp;": [8472], "wreath;": [8768], "xoplus;": [10753], "xotime;": [10754], "xsqcup;": [10758], "xuplus;": [10756], "xwedge;": [8896], "yacute;": [253], "zacute;": [378], "zcaron;": [382], "zeetrf;": [8488] } }, { "length": 6, "entities": { "AElig;": [198], "Aacute": [193], "Acirc;": [194], "Agrave": [192], "Alpha;": [913], "Amacr;": [256], "Aogon;": [260], "Aring;": [197], "Atilde": [195], "Breve;": [728], "Ccedil": [199], "Ccirc;": [264], "Colon;": [8759], "Cross;": [10799], "Dashv;": [10980], "Delta;": [916], "Eacute": [201], "Ecirc;": [202], "Egrave": [200], "Emacr;": [274], "Eogon;": [280], "Equal;": [10869], "Gamma;": [915], "Gcirc;": [284], "Hacek;": [711], "Hcirc;": [292], "IJlig;": [306], "Iacute": [205], "Icirc;": [206], "Igrave": [204], "Imacr;": [298], "Iogon;": [302], "Iukcy;": [1030], "Jcirc;": [308], "Jukcy;": [1028], "Kappa;": [922], "Ntilde": [209], "OElig;": [338], "Oacute": [211], "Ocirc;": [212], "Ograve": [210], "Omacr;": [332], "Omega;": [937], "Oslash": [216], "Otilde": [213], "Prime;": [8243], "RBarr;": [10512], "Scirc;": [348], "Sigma;": [931], "THORN;": [222], "TRADE;": [8482], "TSHcy;": [1035], "Theta;": [920], "Tilde;": [8764], "Uacute": [218], "Ubrcy;": [1038], "Ucirc;": [219], "Ugrave": [217], "Umacr;": [362], "Union;": [8899], "Uogon;": [370], "UpTee;": [8869], "Uring;": [366], "VDash;": [8875], "Vdash;": [8873], "Wcirc;": [372], "Wedge;": [8896], "Yacute": [221], "Ycirc;": [374], "aacute": [225], "acirc;": [226], "acute;": [180], "aelig;": [230], "agrave": [224], "aleph;": [8501], "alpha;": [945], "amacr;": [257], "amalg;": [10815], "angle;": [8736], "angrt;": [8735], "angst;": [197], "aogon;": [261], "aring;": [229], "asymp;": [8776], "atilde": [227], "awint;": [10769], "bcong;": [8780], "bdquo;": [8222], "bepsi;": [1014], "blank;": [9251], "blk12;": [9618], "blk14;": [9617], "blk34;": [9619], "block;": [9608], "boxDL;": [9559], "boxDR;": [9556], "boxDl;": [9558], "boxDr;": [9555], "boxHD;": [9574], "boxHU;": [9577], "boxHd;": [9572], "boxHu;": [9575], "boxUL;": [9565], "boxUR;": [9562], "boxUl;": [9564], "boxUr;": [9561], "boxVH;": [9580], "boxVL;": [9571], "boxVR;": [9568], "boxVh;": [9579], "boxVl;": [9570], "boxVr;": [9567], "boxdL;": [9557], "boxdR;": [9554], "boxdl;": [9488], "boxdr;": [9484], "boxhD;": [9573], "boxhU;": [9576], "boxhd;": [9516], "boxhu;": [9524], "boxuL;": [9563], "boxuR;": [9560], "boxul;": [9496], "boxur;": [9492], "boxvH;": [9578], "boxvL;": [9569], "boxvR;": [9566], "boxvh;": [9532], "boxvl;": [9508], "boxvr;": [9500], "breve;": [728], "brvbar": [166], "bsemi;": [8271], "bsime;": [8909], "bsolb;": [10693], "bumpE;": [10926], "bumpe;": [8783], "caret;": [8257], "caron;": [711], "ccaps;": [10829], "ccedil": [231], "ccirc;": [265], "ccups;": [10828], "cedil;": [184], "check;": [10003], "clubs;": [9827], "colon;": [58], "comma;": [44], "crarr;": [8629], "cross;": [10007], "csube;": [10961], "csupe;": [10962], "ctdot;": [8943], "cuepr;": [8926], "cuesc;": [8927], "cupor;": [10821], "curren": [164], "cuvee;": [8910], "cuwed;": [8911], "cwint;": [8753], "dashv;": [8867], "dblac;": [733], "ddarr;": [8650], "delta;": [948], "dharl;": [8643], "dharr;": [8642], "diams;": [9830], "disin;": [8946], "divide": [247], "doteq;": [8784], "dtdot;": [8945], "dtrif;": [9662], "duarr;": [8693], "duhar;": [10607], "eDDot;": [10871], "eacute": [233], "ecirc;": [234], "efDot;": [8786], "egrave": [232], "emacr;": [275], "empty;": [8709], "eogon;": [281], "eplus;": [10865], "epsiv;": [1013], "eqsim;": [8770], "equiv;": [8801], "erDot;": [8787], "erarr;": [10609], "esdot;": [8784], "exist;": [8707], "fflig;": [64256], "filig;": [64257], "fjlig;": [102, 106], "fllig;": [64258], "fltns;": [9649], "forkv;": [10969], "frac12": [189], "frac14": [188], "frac34": [190], "frasl;": [8260], "frown;": [8994], "gamma;": [947], "gcirc;": [285], "gescc;": [10921], "gimel;": [8503], "gneqq;": [8809], "gnsim;": [8935], "grave;": [96], "gsime;": [10894], "gsiml;": [10896], "gtcir;": [10874], "gtdot;": [8919], "harrw;": [8621], "hcirc;": [293], "hoarr;": [8703], "iacute": [237], "icirc;": [238], "iexcl;": [161], "igrave": [236], "iiint;": [8749], "iiota;": [8489], "ijlig;": [307], "imacr;": [299], "image;": [8465], "imath;": [305], "imped;": [437], "infin;": [8734], "iogon;": [303], "iprod;": [10812], "iquest": [191], "isinE;": [8953], "isins;": [8948], "isinv;": [8712], "iukcy;": [1110], "jcirc;": [309], "jmath;": [567], "jukcy;": [1108], "kappa;": [954], "lAarr;": [8666], "lBarr;": [10510], "langd;": [10641], "laquo;": [171], "larrb;": [8676], "lates;": [10925, 65024], "lbarr;": [10508], "lbbrk;": [10098], "lbrke;": [10635], "lceil;": [8968], "ldquo;": [8220], "lescc;": [10920], "lhard;": [8637], "lharu;": [8636], "lhblk;": [9604], "llarr;": [8647], "lltri;": [9722], "lneqq;": [8808], "lnsim;": [8934], "loang;": [10220], "loarr;": [8701], "lobrk;": [10214], "lopar;": [10629], "lrarr;": [8646], "lrhar;": [8651], "lrtri;": [8895], "lsime;": [10893], "lsimg;": [10895], "lsquo;": [8216], "ltcir;": [10873], "ltdot;": [8918], "ltrie;": [8884], "ltrif;": [9666], "mDDot;": [8762], "mdash;": [8212], "micro;": [181], "middot": [183], "minus;": [8722], "mumap;": [8888], "nabla;": [8711], "napid;": [8779, 824], "napos;": [329], "natur;": [9838], "nbump;": [8782, 824], "ncong;": [8775], "ndash;": [8211], "neArr;": [8663], "nearr;": [8599], "nedot;": [8784, 824], "nesim;": [8770, 824], "ngeqq;": [8807, 824], "ngsim;": [8821], "nhArr;": [8654], "nharr;": [8622], "nhpar;": [10994], "nlArr;": [8653], "nlarr;": [8602], "nleqq;": [8806, 824], "nless;": [8814], "nlsim;": [8820], "nltri;": [8938], "notin;": [8713], "notni;": [8716], "npart;": [8706, 824], "nprec;": [8832], "nrArr;": [8655], "nrarr;": [8603], "nrtri;": [8939], "nsime;": [8772], "nsmid;": [8740], "nspar;": [8742], "nsubE;": [10949, 824], "nsube;": [8840], "nsucc;": [8833], "nsupE;": [10950, 824], "nsupe;": [8841], "ntilde": [241], "numsp;": [8199], "nvsim;": [8764, 8402], "nwArr;": [8662], "nwarr;": [8598], "oacute": [243], "ocirc;": [244], "odash;": [8861], "oelig;": [339], "ofcir;": [10687], "ograve": [242], "ohbar;": [10677], "olarr;": [8634], "olcir;": [10686], "oline;": [8254], "omacr;": [333], "omega;": [969], "operp;": [10681], "oplus;": [8853], "orarr;": [8635], "order;": [8500], "oslash": [248], "otilde": [245], "ovbar;": [9021], "parsl;": [11005], "phone;": [9742], "plusb;": [8862], "pluse;": [10866], "plusmn": [177], "pound;": [163], "prcue;": [8828], "prime;": [8242], "prnap;": [10937], "prsim;": [8830], "quest;": [63], "rAarr;": [8667], "rBarr;": [10511], "radic;": [8730], "rangd;": [10642], "range;": [10661], "raquo;": [187], "rarrb;": [8677], "rarrc;": [10547], "rarrw;": [8605], "ratio;": [8758], "rbarr;": [10509], "rbbrk;": [10099], "rbrke;": [10636], "rceil;": [8969], "rdquo;": [8221], "reals;": [8477], "rhard;": [8641], "rharu;": [8640], "rlarr;": [8644], "rlhar;": [8652], "rnmid;": [10990], "roang;": [10221], "roarr;": [8702], "robrk;": [10215], "ropar;": [10630], "rrarr;": [8649], "rsquo;": [8217], "rtrie;": [8885], "rtrif;": [9656], "sbquo;": [8218], "sccue;": [8829], "scirc;": [349], "scnap;": [10938], "scsim;": [8831], "sdotb;": [8865], "sdote;": [10854], "seArr;": [8664], "searr;": [8600], "setmn;": [8726], "sharp;": [9839], "sigma;": [963], "simeq;": [8771], "simgE;": [10912], "simlE;": [10911], "simne;": [8774], "slarr;": [8592], "smile;": [8995], "smtes;": [10924, 65024], "sqcap;": [8851], "sqcup;": [8852], "sqsub;": [8847], "sqsup;": [8848], "srarr;": [8594], "starf;": [9733], "strns;": [175], "subnE;": [10955], "subne;": [8842], "supnE;": [10956], "supne;": [8843], "swArr;": [8665], "swarr;": [8601], "szlig;": [223], "theta;": [952], "thkap;": [8776], "thorn;": [254], "tilde;": [732], "times;": [215], "trade;": [8482], "trisb;": [10701], "tshcy;": [1115], "twixt;": [8812], "uacute": [250], "ubrcy;": [1118], "ucirc;": [251], "udarr;": [8645], "udhar;": [10606], "ugrave": [249], "uharl;": [8639], "uharr;": [8638], "uhblk;": [9600], "ultri;": [9720], "umacr;": [363], "uogon;": [371], "uplus;": [8846], "upsih;": [978], "uring;": [367], "urtri;": [9721], "utdot;": [8944], "utrif;": [9652], "uuarr;": [8648], "vBarv;": [10985], "vDash;": [8872], "varpi;": [982], "vdash;": [8866], "veeeq;": [8794], "vltri;": [8882], "vnsub;": [8834, 8402], "vnsup;": [8835, 8402], "vprop;": [8733], "vrtri;": [8883], "wcirc;": [373], "wedge;": [8743], "xcirc;": [9711], "xdtri;": [9661], "xhArr;": [10234], "xharr;": [10231], "xlArr;": [10232], "xlarr;": [10229], "xodot;": [10752], "xrArr;": [10233], "xrarr;": [10230], "xutri;": [9651], "yacute": [253], "ycirc;": [375] } }, { "length": 5, "entities": { "AElig": [198], "Acirc": [194], "Aopf;": [120120], "Aring": [197], "Ascr;": [119964], "Auml;": [196], "Barv;": [10983], "Beta;": [914], "Bopf;": [120121], "Bscr;": [8492], "CHcy;": [1063], "COPY;": [169], "Cdot;": [266], "Copf;": [8450], "Cscr;": [119966], "DJcy;": [1026], "DScy;": [1029], "DZcy;": [1039], "Darr;": [8609], "Dopf;": [120123], "Dscr;": [119967], "Ecirc": [202], "Edot;": [278], "Eopf;": [120124], "Escr;": [8496], "Esim;": [10867], "Euml;": [203], "Fopf;": [120125], "Fscr;": [8497], "GJcy;": [1027], "Gdot;": [288], "Gopf;": [120126], "Gscr;": [119970], "Hopf;": [8461], "Hscr;": [8459], "IEcy;": [1045], "IOcy;": [1025], "Icirc": [206], "Idot;": [304], "Iopf;": [120128], "Iota;": [921], "Iscr;": [8464], "Iuml;": [207], "Jopf;": [120129], "Jscr;": [119973], "KHcy;": [1061], "KJcy;": [1036], "Kopf;": [120130], "Kscr;": [119974], "LJcy;": [1033], "Lang;": [10218], "Larr;": [8606], "Lopf;": [120131], "Lscr;": [8466], "Mopf;": [120132], "Mscr;": [8499], "NJcy;": [1034], "Nopf;": [8469], "Nscr;": [119977], "Ocirc": [212], "Oopf;": [120134], "Oscr;": [119978], "Ouml;": [214], "Popf;": [8473], "Pscr;": [119979], "QUOT;": [34], "Qopf;": [8474], "Qscr;": [119980], "Rang;": [10219], "Rarr;": [8608], "Ropf;": [8477], "Rscr;": [8475], "SHcy;": [1064], "Sopf;": [120138], "Sqrt;": [8730], "Sscr;": [119982], "Star;": [8902], "THORN": [222], "TScy;": [1062], "Topf;": [120139], "Tscr;": [119983], "Uarr;": [8607], "Ucirc": [219], "Uopf;": [120140], "Upsi;": [978], "Uscr;": [119984], "Uuml;": [220], "Vbar;": [10987], "Vert;": [8214], "Vopf;": [120141], "Vscr;": [119985], "Wopf;": [120142], "Wscr;": [119986], "Xopf;": [120143], "Xscr;": [119987], "YAcy;": [1071], "YIcy;": [1031], "YUcy;": [1070], "Yopf;": [120144], "Yscr;": [119988], "Yuml;": [376], "ZHcy;": [1046], "Zdot;": [379], "Zeta;": [918], "Zopf;": [8484], "Zscr;": [119989], "acirc": [226], "acute": [180], "aelig": [230], "andd;": [10844], "andv;": [10842], "ange;": [10660], "aopf;": [120146], "apid;": [8779], "apos;": [39], "aring": [229], "ascr;": [119990], "auml;": [228], "bNot;": [10989], "bbrk;": [9141], "beta;": [946], "beth;": [8502], "bnot;": [8976], "bopf;": [120147], "boxH;": [9552], "boxV;": [9553], "boxh;": [9472], "boxv;": [9474], "bscr;": [119991], "bsim;": [8765], "bsol;": [92], "bull;": [8226], "bump;": [8782], "caps;": [8745, 65024], "cdot;": [267], "cedil": [184], "cent;": [162], "chcy;": [1095], "cirE;": [10691], "circ;": [710], "cire;": [8791], "comp;": [8705], "cong;": [8773], "copf;": [120148], "copy;": [169], "cscr;": [119992], "csub;": [10959], "csup;": [10960], "cups;": [8746, 65024], "dArr;": [8659], "dHar;": [10597], "darr;": [8595], "dash;": [8208], "diam;": [8900], "djcy;": [1106], "dopf;": [120149], "dscr;": [119993], "dscy;": [1109], "dsol;": [10742], "dtri;": [9663], "dzcy;": [1119], "eDot;": [8785], "ecir;": [8790], "ecirc": [234], "edot;": [279], "emsp;": [8195], "ensp;": [8194], "eopf;": [120150], "epar;": [8917], "epsi;": [949], "escr;": [8495], "esim;": [8770], "euml;": [235], "euro;": [8364], "excl;": [33], "flat;": [9837], "fnof;": [402], "fopf;": [120151], "fork;": [8916], "fscr;": [119995], "gdot;": [289], "geqq;": [8807], "gesl;": [8923, 65024], "gjcy;": [1107], "gnap;": [10890], "gneq;": [10888], "gopf;": [120152], "gscr;": [8458], "gsim;": [8819], "gtcc;": [10919], "gvnE;": [8809, 65024], "hArr;": [8660], "half;": [189], "harr;": [8596], "hbar;": [8463], "hopf;": [120153], "hscr;": [119997], "icirc": [238], "iecy;": [1077], "iexcl": [161], "imof;": [8887], "iocy;": [1105], "iopf;": [120154], "iota;": [953], "iscr;": [119998], "isin;": [8712], "iuml;": [239], "jopf;": [120155], "jscr;": [119999], "khcy;": [1093], "kjcy;": [1116], "kopf;": [120156], "kscr;": [120000], "lArr;": [8656], "lHar;": [10594], "lang;": [10216], "laquo": [171], "larr;": [8592], "late;": [10925], "lcub;": [123], "ldca;": [10550], "ldsh;": [8626], "leqq;": [8806], "lesg;": [8922, 65024], "ljcy;": [1113], "lnap;": [10889], "lneq;": [10887], "lopf;": [120157], "lozf;": [10731], "lpar;": [40], "lscr;": [120001], "lsim;": [8818], "lsqb;": [91], "ltcc;": [10918], "ltri;": [9667], "lvnE;": [8808, 65024], "macr;": [175], "male;": [9794], "malt;": [10016], "micro": [181], "mlcp;": [10971], "mldr;": [8230], "mopf;": [120158], "mscr;": [120002], "nGtv;": [8811, 824], "nLtv;": [8810, 824], "nang;": [8736, 8402], "napE;": [10864, 824], "nbsp;": [160], "ncap;": [10819], "ncup;": [10818], "ngeq;": [8817], "nges;": [10878, 824], "ngtr;": [8815], "nisd;": [8954], "njcy;": [1114], "nldr;": [8229], "nleq;": [8816], "nles;": [10877, 824], "nmid;": [8740], "nopf;": [120159], "npar;": [8742], "npre;": [10927, 824], "nsce;": [10928, 824], "nscr;": [120003], "nsim;": [8769], "nsub;": [8836], "nsup;": [8837], "ntgl;": [8825], "ntlg;": [8824], "nvap;": [8781, 8402], "nvge;": [8805, 8402], "nvgt;": [62, 8402], "nvle;": [8804, 8402], "nvlt;": [60, 8402], "oast;": [8859], "ocir;": [8858], "ocirc": [244], "odiv;": [10808], "odot;": [8857], "ogon;": [731], "oint;": [8750], "omid;": [10678], "oopf;": [120160], "opar;": [10679], "ordf;": [170], "ordm;": [186], "oror;": [10838], "oscr;": [8500], "osol;": [8856], "ouml;": [246], "para;": [182], "part;": [8706], "perp;": [8869], "phiv;": [981], "plus;": [43], "popf;": [120161], "pound": [163], "prap;": [10935], "prec;": [8826], "prnE;": [10933], "prod;": [8719], "prop;": [8733], "pscr;": [120005], "qint;": [10764], "qopf;": [120162], "qscr;": [120006], "quot;": [34], "rArr;": [8658], "rHar;": [10596], "race;": [8765, 817], "rang;": [10217], "raquo": [187], "rarr;": [8594], "rcub;": [125], "rdca;": [10551], "rdsh;": [8627], "real;": [8476], "rect;": [9645], "rhov;": [1009], "ring;": [730], "ropf;": [120163], "rpar;": [41], "rscr;": [120007], "rsqb;": [93], "rtri;": [9657], "scap;": [10936], "scnE;": [10934], "sdot;": [8901], "sect;": [167], "semi;": [59], "sext;": [10038], "shcy;": [1096], "sime;": [8771], "simg;": [10910], "siml;": [10909], "smid;": [8739], "smte;": [10924], "solb;": [10692], "sopf;": [120164], "spar;": [8741], "squf;": [9642], "sscr;": [120008], "star;": [9734], "subE;": [10949], "sube;": [8838], "succ;": [8827], "sung;": [9834], "sup1;": [185], "sup2;": [178], "sup3;": [179], "supE;": [10950], "supe;": [8839], "szlig": [223], "tbrk;": [9140], "tdot;": [8411], "thorn": [254], "times": [215], "tint;": [8749], "toea;": [10536], "topf;": [120165], "tosa;": [10537], "trie;": [8796], "tscr;": [120009], "tscy;": [1094], "uArr;": [8657], "uHar;": [10595], "uarr;": [8593], "ucirc": [251], "uopf;": [120166], "upsi;": [965], "uscr;": [120010], "utri;": [9653], "uuml;": [252], "vArr;": [8661], "vBar;": [10984], "varr;": [8597], "vert;": [124], "vopf;": [120167], "vscr;": [120011], "wopf;": [120168], "wscr;": [120012], "xcap;": [8898], "xcup;": [8899], "xmap;": [10236], "xnis;": [8955], "xopf;": [120169], "xscr;": [120013], "xvee;": [8897], "yacy;": [1103], "yicy;": [1111], "yopf;": [120170], "yscr;": [120014], "yucy;": [1102], "yuml;": [255], "zdot;": [380], "zeta;": [950], "zhcy;": [1078], "zopf;": [120171], "zscr;": [120015], "zwnj;": [8204] } }, { "length": 4, "entities": { "AMP;": [38], "Acy;": [1040], "Afr;": [120068], "And;": [10835], "Auml": [196], "Bcy;": [1041], "Bfr;": [120069], "COPY": [169], "Cap;": [8914], "Cfr;": [8493], "Chi;": [935], "Cup;": [8915], "Dcy;": [1044], "Del;": [8711], "Dfr;": [120071], "Dot;": [168], "ENG;": [330], "ETH;": [208], "Ecy;": [1069], "Efr;": [120072], "Eta;": [919], "Euml": [203], "Fcy;": [1060], "Ffr;": [120073], "Gcy;": [1043], "Gfr;": [120074], "Hat;": [94], "Hfr;": [8460], "Icy;": [1048], "Ifr;": [8465], "Int;": [8748], "Iuml": [207], "Jcy;": [1049], "Jfr;": [120077], "Kcy;": [1050], "Kfr;": [120078], "Lcy;": [1051], "Lfr;": [120079], "Lsh;": [8624], "Map;": [10501], "Mcy;": [1052], "Mfr;": [120080], "Ncy;": [1053], "Nfr;": [120081], "Not;": [10988], "Ocy;": [1054], "Ofr;": [120082], "Ouml": [214], "Pcy;": [1055], "Pfr;": [120083], "Phi;": [934], "Psi;": [936], "QUOT": [34], "Qfr;": [120084], "REG;": [174], "Rcy;": [1056], "Rfr;": [8476], "Rho;": [929], "Rsh;": [8625], "Scy;": [1057], "Sfr;": [120086], "Sub;": [8912], "Sum;": [8721], "Sup;": [8913], "Tab;": [9], "Tau;": [932], "Tcy;": [1058], "Tfr;": [120087], "Ucy;": [1059], "Ufr;": [120088], "Uuml": [220], "Vcy;": [1042], "Vee;": [8897], "Vfr;": [120089], "Wfr;": [120090], "Xfr;": [120091], "Ycy;": [1067], "Yfr;": [120092], "Zcy;": [1047], "Zfr;": [8488], "acE;": [8766, 819], "acd;": [8767], "acy;": [1072], "afr;": [120094], "amp;": [38], "and;": [8743], "ang;": [8736], "apE;": [10864], "ape;": [8778], "ast;": [42], "auml": [228], "bcy;": [1073], "bfr;": [120095], "bne;": [61, 8421], "bot;": [8869], "cap;": [8745], "cent": [162], "cfr;": [120096], "chi;": [967], "cir;": [9675], "copy": [169], "cup;": [8746], "dcy;": [1076], "deg;": [176], "dfr;": [120097], "die;": [168], "div;": [247], "dot;": [729], "ecy;": [1101], "efr;": [120098], "egs;": [10902], "ell;": [8467], "els;": [10901], "eng;": [331], "eta;": [951], "eth;": [240], "euml": [235], "fcy;": [1092], "ffr;": [120099], "gEl;": [10892], "gap;": [10886], "gcy;": [1075], "gel;": [8923], "geq;": [8805], "ges;": [10878], "gfr;": [120100], "ggg;": [8921], "glE;": [10898], "gla;": [10917], "glj;": [10916], "gnE;": [8809], "gne;": [10888], "hfr;": [120101], "icy;": [1080], "iff;": [8660], "ifr;": [120102], "int;": [8747], "iuml": [239], "jcy;": [1081], "jfr;": [120103], "kcy;": [1082], "kfr;": [120104], "lEg;": [10891], "lap;": [10885], "lat;": [10923], "lcy;": [1083], "leg;": [8922], "leq;": [8804], "les;": [10877], "lfr;": [120105], "lgE;": [10897], "lnE;": [8808], "lne;": [10887], "loz;": [9674], "lrm;": [8206], "lsh;": [8624], "macr": [175], "map;": [8614], "mcy;": [1084], "mfr;": [120106], "mho;": [8487], "mid;": [8739], "nGg;": [8921, 824], "nGt;": [8811, 8402], "nLl;": [8920, 824], "nLt;": [8810, 8402], "nap;": [8777], "nbsp": [160], "ncy;": [1085], "nfr;": [120107], "ngE;": [8807, 824], "nge;": [8817], "ngt;": [8815], "nis;": [8956], "niv;": [8715], "nlE;": [8806, 824], "nle;": [8816], "nlt;": [8814], "not;": [172], "npr;": [8832], "nsc;": [8833], "num;": [35], "ocy;": [1086], "ofr;": [120108], "ogt;": [10689], "ohm;": [937], "olt;": [10688], "ord;": [10845], "ordf": [170], "ordm": [186], "orv;": [10843], "ouml": [246], "par;": [8741], "para": [182], "pcy;": [1087], "pfr;": [120109], "phi;": [966], "piv;": [982], "prE;": [10931], "pre;": [10927], "psi;": [968], "qfr;": [120110], "quot": [34], "rcy;": [1088], "reg;": [174], "rfr;": [120111], "rho;": [961], "rlm;": [8207], "rsh;": [8625], "scE;": [10932], "sce;": [10928], "scy;": [1089], "sect": [167], "sfr;": [120112], "shy;": [173], "sim;": [8764], "smt;": [10922], "sol;": [47], "squ;": [9633], "sub;": [8834], "sum;": [8721], "sup1": [185], "sup2": [178], "sup3": [179], "sup;": [8835], "tau;": [964], "tcy;": [1090], "tfr;": [120113], "top;": [8868], "ucy;": [1091], "ufr;": [120114], "uml;": [168], "uuml": [252], "vcy;": [1074], "vee;": [8744], "vfr;": [120115], "wfr;": [120116], "xfr;": [120117], "ycy;": [1099], "yen;": [165], "yfr;": [120118], "yuml": [255], "zcy;": [1079], "zfr;": [120119], "zwj;": [8205] } }, { "length": 3, "entities": { "AMP": [38], "DD;": [8517], "ETH": [208], "GT;": [62], "Gg;": [8921], "Gt;": [8811], "Im;": [8465], "LT;": [60], "Ll;": [8920], "Lt;": [8810], "Mu;": [924], "Nu;": [925], "Or;": [10836], "Pi;": [928], "Pr;": [10939], "REG": [174], "Re;": [8476], "Sc;": [10940], "Xi;": [926], "ac;": [8766], "af;": [8289], "amp": [38], "ap;": [8776], "dd;": [8518], "deg": [176], "ee;": [8519], "eg;": [10906], "el;": [10905], "eth": [240], "gE;": [8807], "ge;": [8805], "gg;": [8811], "gl;": [8823], "gt;": [62], "ic;": [8291], "ii;": [8520], "in;": [8712], "it;": [8290], "lE;": [8806], "le;": [8804], "lg;": [8822], "ll;": [8810], "lt;": [60], "mp;": [8723], "mu;": [956], "ne;": [8800], "ni;": [8715], "not": [172], "nu;": [957], "oS;": [9416], "or;": [8744], "pi;": [960], "pm;": [177], "pr;": [8826], "reg": [174], "rx;": [8478], "sc;": [8827], "shy": [173], "uml": [168], "wp;": [8472], "wr;": [8768], "xi;": [958], "yen": [165] } }, { "length": 2, "entities": { "GT": [62], "LT": [60], "gt": [62], "lt": [60] } }];
|
2020 |
|
2021 | const EOF = -1;
|
2022 | const NULL = 0x00;
|
2023 | const TABULATION = 0x09;
|
2024 | const CARRIAGE_RETURN = 0x0D;
|
2025 | const LINE_FEED = 0x0A;
|
2026 | const FORM_FEED = 0x0C;
|
2027 | const SPACE = 0x20;
|
2028 | const EXCLAMATION_MARK = 0x21;
|
2029 | const QUOTATION_MARK = 0x22;
|
2030 | const NUMBER_SIGN = 0x23;
|
2031 | const AMPERSAND = 0x26;
|
2032 | const APOSTROPHE = 0x27;
|
2033 | const HYPHEN_MINUS = 0x2D;
|
2034 | const SOLIDUS = 0x2F;
|
2035 | const DIGIT_0 = 0x30;
|
2036 | const DIGIT_9 = 0x39;
|
2037 | const SEMICOLON = 0x3B;
|
2038 | const LESS_THAN_SIGN = 0x3C;
|
2039 | const EQUALS_SIGN = 0x3D;
|
2040 | const GREATER_THAN_SIGN = 0x3E;
|
2041 | const QUESTION_MARK = 0x3F;
|
2042 | const LATIN_CAPITAL_A = 0x41;
|
2043 | const LATIN_CAPITAL_D = 0x44;
|
2044 | const LATIN_CAPITAL_F = 0x46;
|
2045 | const LATIN_CAPITAL_X = 0x58;
|
2046 | const LATIN_CAPITAL_Z = 0x5A;
|
2047 | const LEFT_SQUARE_BRACKET = 0x5B;
|
2048 | const RIGHT_SQUARE_BRACKET = 0x5D;
|
2049 | const GRAVE_ACCENT = 0x60;
|
2050 | const LATIN_SMALL_A = 0x61;
|
2051 | const LATIN_SMALL_F = 0x66;
|
2052 | const LATIN_SMALL_X = 0x78;
|
2053 | const LATIN_SMALL_Z = 0x7A;
|
2054 | const LEFT_CURLY_BRACKET = 0x7B;
|
2055 | const RIGHT_CURLY_BRACKET = 0x7D;
|
2056 | const NULL_REPLACEMENT = 0xFFFD;
|
2057 | function isWhitespace(cp) {
|
2058 | return cp === TABULATION || cp === LINE_FEED || cp === FORM_FEED || cp === CARRIAGE_RETURN || cp === SPACE;
|
2059 | }
|
2060 | function isUpperLetter(cp) {
|
2061 | return cp >= LATIN_CAPITAL_A && cp <= LATIN_CAPITAL_Z;
|
2062 | }
|
2063 | function isLowerLetter(cp) {
|
2064 | return cp >= LATIN_SMALL_A && cp <= LATIN_SMALL_Z;
|
2065 | }
|
2066 | function isLetter(cp) {
|
2067 | return isLowerLetter(cp) || isUpperLetter(cp);
|
2068 | }
|
2069 | function isDigit(cp) {
|
2070 | return cp >= DIGIT_0 && cp <= DIGIT_9;
|
2071 | }
|
2072 | function isUpperHexDigit(cp) {
|
2073 | return cp >= LATIN_CAPITAL_A && cp <= LATIN_CAPITAL_F;
|
2074 | }
|
2075 | function isLowerHexDigit(cp) {
|
2076 | return cp >= LATIN_SMALL_A && cp <= LATIN_SMALL_F;
|
2077 | }
|
2078 | function isHexDigit(cp) {
|
2079 | return isDigit(cp) || isUpperHexDigit(cp) || isLowerHexDigit(cp);
|
2080 | }
|
2081 | function isControl(cp) {
|
2082 | return (cp >= 0 && cp <= 0x1F) || (cp >= 0x7F && cp <= 0x9F);
|
2083 | }
|
2084 | function isSurrogate(cp) {
|
2085 | return cp >= 0xD800 && cp <= 0xDFFF;
|
2086 | }
|
2087 | function isSurrogatePair(cp) {
|
2088 | return cp >= 0xDC00 && cp <= 0xDFFF;
|
2089 | }
|
2090 | function isNonCharacter(cp) {
|
2091 | return ((cp >= 0xFDD0 && cp <= 0xFDEF) ||
|
2092 | ((cp & 0xFFFE) === 0xFFFE && cp <= 0x10FFFF));
|
2093 | }
|
2094 | function toLowerCodePoint(cp) {
|
2095 | return cp + 0x0020;
|
2096 | }
|
2097 |
|
2098 | class Tokenizer {
|
2099 | constructor(text) {
|
2100 | debug("[html] the source code length: %d", text.length);
|
2101 | this.text = text;
|
2102 | this.gaps = [];
|
2103 | this.lineTerminators = [];
|
2104 | this.lastCodePoint = NULL;
|
2105 | this.offset = -1;
|
2106 | this.column = -1;
|
2107 | this.line = 1;
|
2108 | this.state = "DATA";
|
2109 | this.returnState = "DATA";
|
2110 | this.reconsuming = false;
|
2111 | this.buffer = [];
|
2112 | this.crStartOffset = -1;
|
2113 | this.crCode = 0;
|
2114 | this.errors = [];
|
2115 | this.committedToken = null;
|
2116 | this.provisionalToken = null;
|
2117 | this.currentToken = null;
|
2118 | this.lastTagOpenToken = null;
|
2119 | this.tokenStartOffset = -1;
|
2120 | this.tokenStartColumn = -1;
|
2121 | this.tokenStartLine = 1;
|
2122 | this.namespace = NS.HTML;
|
2123 | this.expressionEnabled = false;
|
2124 | }
|
2125 | nextToken() {
|
2126 | let cp = this.lastCodePoint;
|
2127 | while (this.committedToken == null &&
|
2128 | (cp !== EOF || this.reconsuming)) {
|
2129 | if (this.provisionalToken != null && !this.isProvisionalState()) {
|
2130 | this.commitProvisionalToken();
|
2131 | if (this.committedToken != null) {
|
2132 | break;
|
2133 | }
|
2134 | }
|
2135 | if (this.reconsuming) {
|
2136 | this.reconsuming = false;
|
2137 | cp = this.lastCodePoint;
|
2138 | }
|
2139 | else {
|
2140 | cp = this.consumeNextCodePoint();
|
2141 | }
|
2142 | debug("[html] parse", cp, this.state);
|
2143 | this.state = this[this.state](cp);
|
2144 | }
|
2145 | {
|
2146 | const token = this.consumeCommittedToken();
|
2147 | if (token != null) {
|
2148 | return token;
|
2149 | }
|
2150 | }
|
2151 | assert(cp === EOF);
|
2152 | if (this.currentToken != null) {
|
2153 | this.endToken();
|
2154 | const token = this.consumeCommittedToken();
|
2155 | if (token != null) {
|
2156 | return token;
|
2157 | }
|
2158 | }
|
2159 | return this.currentToken;
|
2160 | }
|
2161 | consumeCommittedToken() {
|
2162 | const token = this.committedToken;
|
2163 | this.committedToken = null;
|
2164 | return token;
|
2165 | }
|
2166 | consumeNextCodePoint() {
|
2167 | if (this.offset >= this.text.length) {
|
2168 | this.lastCodePoint = EOF;
|
2169 | return EOF;
|
2170 | }
|
2171 | this.offset += this.lastCodePoint >= 0x10000 ? 2 : 1;
|
2172 | if (this.offset >= this.text.length) {
|
2173 | this.advanceLocation();
|
2174 | this.lastCodePoint = EOF;
|
2175 | return EOF;
|
2176 | }
|
2177 | const cp = this.text.codePointAt(this.offset);
|
2178 | if (isSurrogate(this.text.charCodeAt(this.offset)) &&
|
2179 | !isSurrogatePair(this.text.charCodeAt(this.offset + 1))) {
|
2180 | this.reportParseError("surrogate-in-input-stream");
|
2181 | }
|
2182 | if (isNonCharacter(cp)) {
|
2183 | this.reportParseError("noncharacter-in-input-stream");
|
2184 | }
|
2185 | if (isControl(cp) && !isWhitespace(cp) && cp !== NULL) {
|
2186 | this.reportParseError("control-character-in-input-stream");
|
2187 | }
|
2188 | if (this.lastCodePoint === CARRIAGE_RETURN && cp === LINE_FEED) {
|
2189 | this.lastCodePoint = LINE_FEED;
|
2190 | this.gaps.push(this.offset);
|
2191 | return this.consumeNextCodePoint();
|
2192 | }
|
2193 | this.advanceLocation();
|
2194 | this.lastCodePoint = cp;
|
2195 | if (cp === CARRIAGE_RETURN) {
|
2196 | return LINE_FEED;
|
2197 | }
|
2198 | return cp;
|
2199 | }
|
2200 | advanceLocation() {
|
2201 | if (this.lastCodePoint === LINE_FEED) {
|
2202 | this.lineTerminators.push(this.offset);
|
2203 | this.line += 1;
|
2204 | this.column = 0;
|
2205 | }
|
2206 | else {
|
2207 | this.column += this.lastCodePoint >= 0x10000 ? 2 : 1;
|
2208 | }
|
2209 | }
|
2210 | reconsumeAs(state) {
|
2211 | this.reconsuming = true;
|
2212 | return state;
|
2213 | }
|
2214 | reportParseError(code) {
|
2215 | const error = ParseError.fromCode(code, this.offset, this.line, this.column);
|
2216 | this.errors.push(error);
|
2217 | debug("[html] syntax error:", error.message);
|
2218 | }
|
2219 | setStartTokenMark() {
|
2220 | this.tokenStartOffset = this.offset;
|
2221 | this.tokenStartLine = this.line;
|
2222 | this.tokenStartColumn = this.column;
|
2223 | }
|
2224 | clearStartTokenMark() {
|
2225 | this.tokenStartOffset = -1;
|
2226 | }
|
2227 | startToken(type) {
|
2228 | if (this.tokenStartOffset === -1) {
|
2229 | this.setStartTokenMark();
|
2230 | }
|
2231 | const offset = this.tokenStartOffset;
|
2232 | const line = this.tokenStartLine;
|
2233 | const column = this.tokenStartColumn;
|
2234 | if (this.currentToken != null) {
|
2235 | this.endToken();
|
2236 | }
|
2237 | this.tokenStartOffset = -1;
|
2238 | const token = (this.currentToken = {
|
2239 | type,
|
2240 | range: [offset, -1],
|
2241 | loc: {
|
2242 | start: { line, column },
|
2243 | end: { line: -1, column: -1 },
|
2244 | },
|
2245 | value: "",
|
2246 | });
|
2247 | debug("[html] start token: %d %s", offset, token.type);
|
2248 | return this.currentToken;
|
2249 | }
|
2250 | endToken() {
|
2251 | if (this.currentToken == null) {
|
2252 | throw new Error("Invalid state");
|
2253 | }
|
2254 | if (this.tokenStartOffset === -1) {
|
2255 | this.setStartTokenMark();
|
2256 | }
|
2257 | const token = this.currentToken;
|
2258 | const offset = this.tokenStartOffset;
|
2259 | const line = this.tokenStartLine;
|
2260 | const column = this.tokenStartColumn;
|
2261 | const provisional = this.isProvisionalState();
|
2262 | this.currentToken = null;
|
2263 | this.tokenStartOffset = -1;
|
2264 | token.range[1] = offset;
|
2265 | token.loc.end.line = line;
|
2266 | token.loc.end.column = column;
|
2267 | if (token.range[0] === offset && !provisional) {
|
2268 | debug("[html] abandon token: %j %s %j", token.range, token.type, token.value);
|
2269 | return null;
|
2270 | }
|
2271 | if (provisional) {
|
2272 | if (this.provisionalToken != null) {
|
2273 | this.commitProvisionalToken();
|
2274 | }
|
2275 | this.provisionalToken = token;
|
2276 | debug("[html] provisional-commit token: %j %s %j", token.range, token.type, token.value);
|
2277 | }
|
2278 | else {
|
2279 | this.commitToken(token);
|
2280 | }
|
2281 | return token;
|
2282 | }
|
2283 | commitToken(token) {
|
2284 | assert(this.committedToken == null, "Invalid state: the commited token existed already.");
|
2285 | debug("[html] commit token: %j %j %s %j", token.range, token.loc, token.type, token.value);
|
2286 | this.committedToken = token;
|
2287 | if (token.type === "HTMLTagOpen") {
|
2288 | this.lastTagOpenToken = token;
|
2289 | }
|
2290 | }
|
2291 | isProvisionalState() {
|
2292 | return (this.state.startsWith("RCDATA_") ||
|
2293 | this.state.startsWith("RAWTEXT_"));
|
2294 | }
|
2295 | commitProvisionalToken() {
|
2296 | assert(this.provisionalToken != null, "Invalid state: the provisional token was not found.");
|
2297 | const token = this.provisionalToken;
|
2298 | this.provisionalToken = null;
|
2299 | if (token.range[0] < token.range[1]) {
|
2300 | this.commitToken(token);
|
2301 | }
|
2302 | }
|
2303 | rollbackProvisionalToken() {
|
2304 | assert(this.currentToken != null);
|
2305 | assert(this.provisionalToken != null);
|
2306 | const token = this.currentToken;
|
2307 | debug("[html] rollback token: %d %s", token.range[0], token.type);
|
2308 | this.currentToken = this.provisionalToken;
|
2309 | this.provisionalToken = null;
|
2310 | }
|
2311 | appendTokenValue(cp, expected) {
|
2312 | const token = this.currentToken;
|
2313 | if (token == null || (expected != null && token.type !== expected)) {
|
2314 | const msg1 = expected ? `"${expected}" type` : "any token";
|
2315 | const msg2 = token ? `"${token.type}" type` : "no token";
|
2316 | throw new Error(`Tokenizer: Invalid state. Expected ${msg1}, but got ${msg2}.`);
|
2317 | }
|
2318 | token.value += String.fromCodePoint(cp);
|
2319 | }
|
2320 | isAppropriateEndTagOpen() {
|
2321 | return (this.currentToken != null &&
|
2322 | this.lastTagOpenToken != null &&
|
2323 | this.currentToken.type === "HTMLEndTagOpen" &&
|
2324 | this.currentToken.value === this.lastTagOpenToken.value);
|
2325 | }
|
2326 | DATA(cp) {
|
2327 | this.clearStartTokenMark();
|
2328 | while (true) {
|
2329 | const type = isWhitespace(cp) ? "HTMLWhitespace" : "HTMLText";
|
2330 | if (this.currentToken != null && this.currentToken.type !== type) {
|
2331 | this.endToken();
|
2332 | return this.reconsumeAs(this.state);
|
2333 | }
|
2334 | if (this.currentToken == null) {
|
2335 | this.startToken(type);
|
2336 | }
|
2337 | if (cp === AMPERSAND) {
|
2338 | this.returnState = "DATA";
|
2339 | return "CHARACTER_REFERENCE";
|
2340 | }
|
2341 | if (cp === LESS_THAN_SIGN) {
|
2342 | this.setStartTokenMark();
|
2343 | return "TAG_OPEN";
|
2344 | }
|
2345 | if (cp === LEFT_CURLY_BRACKET && this.expressionEnabled) {
|
2346 | this.setStartTokenMark();
|
2347 | this.returnState = "DATA";
|
2348 | return "V_EXPRESSION_START";
|
2349 | }
|
2350 | if (cp === RIGHT_CURLY_BRACKET && this.expressionEnabled) {
|
2351 | this.setStartTokenMark();
|
2352 | this.returnState = "DATA";
|
2353 | return "V_EXPRESSION_END";
|
2354 | }
|
2355 | if (cp === EOF) {
|
2356 | return "DATA";
|
2357 | }
|
2358 | if (cp === NULL) {
|
2359 | this.reportParseError("unexpected-null-character");
|
2360 | }
|
2361 | this.appendTokenValue(cp, type);
|
2362 | cp = this.consumeNextCodePoint();
|
2363 | }
|
2364 | }
|
2365 | RCDATA(cp) {
|
2366 | this.clearStartTokenMark();
|
2367 | while (true) {
|
2368 | const type = isWhitespace(cp) ? "HTMLWhitespace" : "HTMLRCDataText";
|
2369 | if (this.currentToken != null && this.currentToken.type !== type) {
|
2370 | this.endToken();
|
2371 | return this.reconsumeAs(this.state);
|
2372 | }
|
2373 | if (this.currentToken == null) {
|
2374 | this.startToken(type);
|
2375 | }
|
2376 | if (cp === AMPERSAND) {
|
2377 | this.returnState = "RCDATA";
|
2378 | return "CHARACTER_REFERENCE";
|
2379 | }
|
2380 | if (cp === LESS_THAN_SIGN) {
|
2381 | this.setStartTokenMark();
|
2382 | return "RCDATA_LESS_THAN_SIGN";
|
2383 | }
|
2384 | if (cp === LEFT_CURLY_BRACKET && this.expressionEnabled) {
|
2385 | this.setStartTokenMark();
|
2386 | this.returnState = "RCDATA";
|
2387 | return "V_EXPRESSION_START";
|
2388 | }
|
2389 | if (cp === RIGHT_CURLY_BRACKET && this.expressionEnabled) {
|
2390 | this.setStartTokenMark();
|
2391 | this.returnState = "RCDATA";
|
2392 | return "V_EXPRESSION_END";
|
2393 | }
|
2394 | if (cp === EOF) {
|
2395 | return "DATA";
|
2396 | }
|
2397 | if (cp === NULL) {
|
2398 | this.reportParseError("unexpected-null-character");
|
2399 | cp = NULL_REPLACEMENT;
|
2400 | }
|
2401 | this.appendTokenValue(cp, type);
|
2402 | cp = this.consumeNextCodePoint();
|
2403 | }
|
2404 | }
|
2405 | RAWTEXT(cp) {
|
2406 | this.clearStartTokenMark();
|
2407 | while (true) {
|
2408 | const type = isWhitespace(cp) ? "HTMLWhitespace" : "HTMLRawText";
|
2409 | if (this.currentToken != null && this.currentToken.type !== type) {
|
2410 | this.endToken();
|
2411 | return this.reconsumeAs(this.state);
|
2412 | }
|
2413 | if (this.currentToken == null) {
|
2414 | this.startToken(type);
|
2415 | }
|
2416 | if (cp === LESS_THAN_SIGN) {
|
2417 | this.setStartTokenMark();
|
2418 | return "RAWTEXT_LESS_THAN_SIGN";
|
2419 | }
|
2420 | if (cp === LEFT_CURLY_BRACKET && this.expressionEnabled) {
|
2421 | this.setStartTokenMark();
|
2422 | this.returnState = "RAWTEXT";
|
2423 | return "V_EXPRESSION_START";
|
2424 | }
|
2425 | if (cp === RIGHT_CURLY_BRACKET && this.expressionEnabled) {
|
2426 | this.setStartTokenMark();
|
2427 | this.returnState = "RAWTEXT";
|
2428 | return "V_EXPRESSION_END";
|
2429 | }
|
2430 | if (cp === EOF) {
|
2431 | return "DATA";
|
2432 | }
|
2433 | if (cp === NULL) {
|
2434 | this.reportParseError("unexpected-null-character");
|
2435 | cp = NULL_REPLACEMENT;
|
2436 | }
|
2437 | this.appendTokenValue(cp, type);
|
2438 | cp = this.consumeNextCodePoint();
|
2439 | }
|
2440 | }
|
2441 | TAG_OPEN(cp) {
|
2442 | if (cp === EXCLAMATION_MARK) {
|
2443 | return "MARKUP_DECLARATION_OPEN";
|
2444 | }
|
2445 | if (cp === SOLIDUS) {
|
2446 | return "END_TAG_OPEN";
|
2447 | }
|
2448 | if (isLetter(cp)) {
|
2449 | this.startToken("HTMLTagOpen");
|
2450 | return this.reconsumeAs("TAG_NAME");
|
2451 | }
|
2452 | if (cp === QUESTION_MARK) {
|
2453 | this.reportParseError("unexpected-question-mark-instead-of-tag-name");
|
2454 | this.startToken("HTMLBogusComment");
|
2455 | return this.reconsumeAs("BOGUS_COMMENT");
|
2456 | }
|
2457 | if (cp === EOF) {
|
2458 | this.clearStartTokenMark();
|
2459 | this.reportParseError("eof-before-tag-name");
|
2460 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLText");
|
2461 | return "DATA";
|
2462 | }
|
2463 | this.reportParseError("invalid-first-character-of-tag-name");
|
2464 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLText");
|
2465 | return this.reconsumeAs("DATA");
|
2466 | }
|
2467 | END_TAG_OPEN(cp) {
|
2468 | if (isLetter(cp)) {
|
2469 | this.startToken("HTMLEndTagOpen");
|
2470 | return this.reconsumeAs("TAG_NAME");
|
2471 | }
|
2472 | if (cp === GREATER_THAN_SIGN) {
|
2473 | this.endToken();
|
2474 | this.reportParseError("missing-end-tag-name");
|
2475 | return "DATA";
|
2476 | }
|
2477 | if (cp === EOF) {
|
2478 | this.clearStartTokenMark();
|
2479 | this.reportParseError("eof-before-tag-name");
|
2480 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLText");
|
2481 | this.appendTokenValue(SOLIDUS, "HTMLText");
|
2482 | return "DATA";
|
2483 | }
|
2484 | this.reportParseError("invalid-first-character-of-tag-name");
|
2485 | this.startToken("HTMLBogusComment");
|
2486 | return this.reconsumeAs("BOGUS_COMMENT");
|
2487 | }
|
2488 | TAG_NAME(cp) {
|
2489 | while (true) {
|
2490 | if (isWhitespace(cp)) {
|
2491 | this.endToken();
|
2492 | return "BEFORE_ATTRIBUTE_NAME";
|
2493 | }
|
2494 | if (cp === SOLIDUS) {
|
2495 | this.endToken();
|
2496 | this.setStartTokenMark();
|
2497 | return "SELF_CLOSING_START_TAG";
|
2498 | }
|
2499 | if (cp === GREATER_THAN_SIGN) {
|
2500 | this.startToken("HTMLTagClose");
|
2501 | return "DATA";
|
2502 | }
|
2503 | if (cp === EOF) {
|
2504 | this.reportParseError("eof-in-tag");
|
2505 | return "DATA";
|
2506 | }
|
2507 | if (cp === NULL) {
|
2508 | this.reportParseError("unexpected-null-character");
|
2509 | cp = NULL_REPLACEMENT;
|
2510 | }
|
2511 | this.appendTokenValue(isUpperLetter(cp) ? toLowerCodePoint(cp) : cp, null);
|
2512 | cp = this.consumeNextCodePoint();
|
2513 | }
|
2514 | }
|
2515 | RCDATA_LESS_THAN_SIGN(cp) {
|
2516 | if (cp === SOLIDUS) {
|
2517 | this.buffer = [];
|
2518 | return "RCDATA_END_TAG_OPEN";
|
2519 | }
|
2520 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLRCDataText");
|
2521 | return this.reconsumeAs("RCDATA");
|
2522 | }
|
2523 | RCDATA_END_TAG_OPEN(cp) {
|
2524 | if (isLetter(cp)) {
|
2525 | this.startToken("HTMLEndTagOpen");
|
2526 | return this.reconsumeAs("RCDATA_END_TAG_NAME");
|
2527 | }
|
2528 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLRCDataText");
|
2529 | this.appendTokenValue(SOLIDUS, "HTMLRCDataText");
|
2530 | return this.reconsumeAs("RCDATA");
|
2531 | }
|
2532 | RCDATA_END_TAG_NAME(cp) {
|
2533 | while (true) {
|
2534 | if (isWhitespace(cp) && this.isAppropriateEndTagOpen()) {
|
2535 | this.endToken();
|
2536 | return "BEFORE_ATTRIBUTE_NAME";
|
2537 | }
|
2538 | if (cp === SOLIDUS && this.isAppropriateEndTagOpen()) {
|
2539 | this.endToken();
|
2540 | this.setStartTokenMark();
|
2541 | return "SELF_CLOSING_START_TAG";
|
2542 | }
|
2543 | if (cp === GREATER_THAN_SIGN && this.isAppropriateEndTagOpen()) {
|
2544 | this.startToken("HTMLTagClose");
|
2545 | return "DATA";
|
2546 | }
|
2547 | if (!isLetter(cp)) {
|
2548 | this.rollbackProvisionalToken();
|
2549 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLRCDataText");
|
2550 | this.appendTokenValue(SOLIDUS, "HTMLRCDataText");
|
2551 | for (const cp1 of this.buffer) {
|
2552 | this.appendTokenValue(cp1, "HTMLRCDataText");
|
2553 | }
|
2554 | return this.reconsumeAs("RCDATA");
|
2555 | }
|
2556 | this.appendTokenValue(isUpperLetter(cp) ? toLowerCodePoint(cp) : cp, "HTMLEndTagOpen");
|
2557 | this.buffer.push(cp);
|
2558 | cp = this.consumeNextCodePoint();
|
2559 | }
|
2560 | }
|
2561 | RAWTEXT_LESS_THAN_SIGN(cp) {
|
2562 | if (cp === SOLIDUS) {
|
2563 | this.buffer = [];
|
2564 | return "RAWTEXT_END_TAG_OPEN";
|
2565 | }
|
2566 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLRawText");
|
2567 | return this.reconsumeAs("RAWTEXT");
|
2568 | }
|
2569 | RAWTEXT_END_TAG_OPEN(cp) {
|
2570 | if (isLetter(cp)) {
|
2571 | this.startToken("HTMLEndTagOpen");
|
2572 | return this.reconsumeAs("RAWTEXT_END_TAG_NAME");
|
2573 | }
|
2574 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLRawText");
|
2575 | this.appendTokenValue(SOLIDUS, "HTMLRawText");
|
2576 | return this.reconsumeAs("RAWTEXT");
|
2577 | }
|
2578 | RAWTEXT_END_TAG_NAME(cp) {
|
2579 | while (true) {
|
2580 | if (cp === SOLIDUS && this.isAppropriateEndTagOpen()) {
|
2581 | this.endToken();
|
2582 | this.setStartTokenMark();
|
2583 | return "SELF_CLOSING_START_TAG";
|
2584 | }
|
2585 | if (cp === GREATER_THAN_SIGN && this.isAppropriateEndTagOpen()) {
|
2586 | this.startToken("HTMLTagClose");
|
2587 | return "DATA";
|
2588 | }
|
2589 | if (isWhitespace(cp) && this.isAppropriateEndTagOpen()) {
|
2590 | this.endToken();
|
2591 | return "BEFORE_ATTRIBUTE_NAME";
|
2592 | }
|
2593 | if (!isLetter(cp)) {
|
2594 | this.rollbackProvisionalToken();
|
2595 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLRawText");
|
2596 | this.appendTokenValue(SOLIDUS, "HTMLRawText");
|
2597 | for (const cp1 of this.buffer) {
|
2598 | this.appendTokenValue(cp1, "HTMLRawText");
|
2599 | }
|
2600 | return this.reconsumeAs("RAWTEXT");
|
2601 | }
|
2602 | this.appendTokenValue(isUpperLetter(cp) ? toLowerCodePoint(cp) : cp, "HTMLEndTagOpen");
|
2603 | this.buffer.push(cp);
|
2604 | cp = this.consumeNextCodePoint();
|
2605 | }
|
2606 | }
|
2607 | BEFORE_ATTRIBUTE_NAME(cp) {
|
2608 | while (isWhitespace(cp)) {
|
2609 | cp = this.consumeNextCodePoint();
|
2610 | }
|
2611 | if (cp === SOLIDUS || cp === GREATER_THAN_SIGN || cp === EOF) {
|
2612 | return this.reconsumeAs("AFTER_ATTRIBUTE_NAME");
|
2613 | }
|
2614 | if (cp === EQUALS_SIGN) {
|
2615 | this.reportParseError("unexpected-equals-sign-before-attribute-name");
|
2616 | this.startToken("HTMLIdentifier");
|
2617 | this.appendTokenValue(cp, "HTMLIdentifier");
|
2618 | return "ATTRIBUTE_NAME";
|
2619 | }
|
2620 | this.startToken("HTMLIdentifier");
|
2621 | return this.reconsumeAs("ATTRIBUTE_NAME");
|
2622 | }
|
2623 | ATTRIBUTE_NAME(cp) {
|
2624 | while (true) {
|
2625 | if (isWhitespace(cp) ||
|
2626 | cp === SOLIDUS ||
|
2627 | cp === GREATER_THAN_SIGN ||
|
2628 | cp === EOF) {
|
2629 | this.endToken();
|
2630 | return this.reconsumeAs("AFTER_ATTRIBUTE_NAME");
|
2631 | }
|
2632 | if (cp === EQUALS_SIGN) {
|
2633 | this.startToken("HTMLAssociation");
|
2634 | return "BEFORE_ATTRIBUTE_VALUE";
|
2635 | }
|
2636 | if (cp === NULL) {
|
2637 | this.reportParseError("unexpected-null-character");
|
2638 | cp = NULL_REPLACEMENT;
|
2639 | }
|
2640 | if (cp === QUOTATION_MARK ||
|
2641 | cp === APOSTROPHE ||
|
2642 | cp === LESS_THAN_SIGN) {
|
2643 | this.reportParseError("unexpected-character-in-attribute-name");
|
2644 | }
|
2645 | this.appendTokenValue(isUpperLetter(cp) ? toLowerCodePoint(cp) : cp, "HTMLIdentifier");
|
2646 | cp = this.consumeNextCodePoint();
|
2647 | }
|
2648 | }
|
2649 | AFTER_ATTRIBUTE_NAME(cp) {
|
2650 | while (isWhitespace(cp)) {
|
2651 | cp = this.consumeNextCodePoint();
|
2652 | }
|
2653 | if (cp === SOLIDUS) {
|
2654 | this.setStartTokenMark();
|
2655 | return "SELF_CLOSING_START_TAG";
|
2656 | }
|
2657 | if (cp === EQUALS_SIGN) {
|
2658 | this.startToken("HTMLAssociation");
|
2659 | return "BEFORE_ATTRIBUTE_VALUE";
|
2660 | }
|
2661 | if (cp === GREATER_THAN_SIGN) {
|
2662 | this.startToken("HTMLTagClose");
|
2663 | return "DATA";
|
2664 | }
|
2665 | if (cp === EOF) {
|
2666 | this.reportParseError("eof-in-tag");
|
2667 | return "DATA";
|
2668 | }
|
2669 | this.startToken("HTMLIdentifier");
|
2670 | return this.reconsumeAs("ATTRIBUTE_NAME");
|
2671 | }
|
2672 | BEFORE_ATTRIBUTE_VALUE(cp) {
|
2673 | this.endToken();
|
2674 | while (isWhitespace(cp)) {
|
2675 | cp = this.consumeNextCodePoint();
|
2676 | }
|
2677 | if (cp === GREATER_THAN_SIGN) {
|
2678 | this.reportParseError("missing-attribute-value");
|
2679 | this.startToken("HTMLTagClose");
|
2680 | return "DATA";
|
2681 | }
|
2682 | this.startToken("HTMLLiteral");
|
2683 | if (cp === QUOTATION_MARK) {
|
2684 | return "ATTRIBUTE_VALUE_DOUBLE_QUOTED";
|
2685 | }
|
2686 | if (cp === APOSTROPHE) {
|
2687 | return "ATTRIBUTE_VALUE_SINGLE_QUOTED";
|
2688 | }
|
2689 | return this.reconsumeAs("ATTRIBUTE_VALUE_UNQUOTED");
|
2690 | }
|
2691 | ATTRIBUTE_VALUE_DOUBLE_QUOTED(cp) {
|
2692 | while (true) {
|
2693 | if (cp === QUOTATION_MARK) {
|
2694 | return "AFTER_ATTRIBUTE_VALUE_QUOTED";
|
2695 | }
|
2696 | if (cp === AMPERSAND) {
|
2697 | this.returnState = "ATTRIBUTE_VALUE_DOUBLE_QUOTED";
|
2698 | return "CHARACTER_REFERENCE";
|
2699 | }
|
2700 | if (cp === NULL) {
|
2701 | this.reportParseError("unexpected-null-character");
|
2702 | cp = NULL_REPLACEMENT;
|
2703 | }
|
2704 | if (cp === EOF) {
|
2705 | this.reportParseError("eof-in-tag");
|
2706 | return "DATA";
|
2707 | }
|
2708 | this.appendTokenValue(cp, "HTMLLiteral");
|
2709 | cp = this.consumeNextCodePoint();
|
2710 | }
|
2711 | }
|
2712 | ATTRIBUTE_VALUE_SINGLE_QUOTED(cp) {
|
2713 | while (true) {
|
2714 | if (cp === APOSTROPHE) {
|
2715 | return "AFTER_ATTRIBUTE_VALUE_QUOTED";
|
2716 | }
|
2717 | if (cp === AMPERSAND) {
|
2718 | this.returnState = "ATTRIBUTE_VALUE_SINGLE_QUOTED";
|
2719 | return "CHARACTER_REFERENCE";
|
2720 | }
|
2721 | if (cp === NULL) {
|
2722 | this.reportParseError("unexpected-null-character");
|
2723 | cp = NULL_REPLACEMENT;
|
2724 | }
|
2725 | if (cp === EOF) {
|
2726 | this.reportParseError("eof-in-tag");
|
2727 | return "DATA";
|
2728 | }
|
2729 | this.appendTokenValue(cp, "HTMLLiteral");
|
2730 | cp = this.consumeNextCodePoint();
|
2731 | }
|
2732 | }
|
2733 | ATTRIBUTE_VALUE_UNQUOTED(cp) {
|
2734 | while (true) {
|
2735 | if (isWhitespace(cp)) {
|
2736 | this.endToken();
|
2737 | return "BEFORE_ATTRIBUTE_NAME";
|
2738 | }
|
2739 | if (cp === AMPERSAND) {
|
2740 | this.returnState = "ATTRIBUTE_VALUE_UNQUOTED";
|
2741 | return "CHARACTER_REFERENCE";
|
2742 | }
|
2743 | if (cp === GREATER_THAN_SIGN) {
|
2744 | this.startToken("HTMLTagClose");
|
2745 | return "DATA";
|
2746 | }
|
2747 | if (cp === NULL) {
|
2748 | this.reportParseError("unexpected-null-character");
|
2749 | cp = NULL_REPLACEMENT;
|
2750 | }
|
2751 | if (cp === QUOTATION_MARK ||
|
2752 | cp === APOSTROPHE ||
|
2753 | cp === LESS_THAN_SIGN ||
|
2754 | cp === EQUALS_SIGN ||
|
2755 | cp === GRAVE_ACCENT) {
|
2756 | this.reportParseError("unexpected-character-in-unquoted-attribute-value");
|
2757 | }
|
2758 | if (cp === EOF) {
|
2759 | this.reportParseError("eof-in-tag");
|
2760 | return "DATA";
|
2761 | }
|
2762 | this.appendTokenValue(cp, "HTMLLiteral");
|
2763 | cp = this.consumeNextCodePoint();
|
2764 | }
|
2765 | }
|
2766 | AFTER_ATTRIBUTE_VALUE_QUOTED(cp) {
|
2767 | this.endToken();
|
2768 | if (isWhitespace(cp)) {
|
2769 | return "BEFORE_ATTRIBUTE_NAME";
|
2770 | }
|
2771 | if (cp === SOLIDUS) {
|
2772 | this.setStartTokenMark();
|
2773 | return "SELF_CLOSING_START_TAG";
|
2774 | }
|
2775 | if (cp === GREATER_THAN_SIGN) {
|
2776 | this.startToken("HTMLTagClose");
|
2777 | return "DATA";
|
2778 | }
|
2779 | if (cp === EOF) {
|
2780 | this.reportParseError("eof-in-tag");
|
2781 | return "DATA";
|
2782 | }
|
2783 | this.reportParseError("missing-whitespace-between-attributes");
|
2784 | return this.reconsumeAs("BEFORE_ATTRIBUTE_NAME");
|
2785 | }
|
2786 | SELF_CLOSING_START_TAG(cp) {
|
2787 | if (cp === GREATER_THAN_SIGN) {
|
2788 | this.startToken("HTMLSelfClosingTagClose");
|
2789 | return "DATA";
|
2790 | }
|
2791 | if (cp === EOF) {
|
2792 | this.reportParseError("eof-in-tag");
|
2793 | return "DATA";
|
2794 | }
|
2795 | this.reportParseError("unexpected-solidus-in-tag");
|
2796 | this.clearStartTokenMark();
|
2797 | return this.reconsumeAs("BEFORE_ATTRIBUTE_NAME");
|
2798 | }
|
2799 | BOGUS_COMMENT(cp) {
|
2800 | while (true) {
|
2801 | if (cp === GREATER_THAN_SIGN) {
|
2802 | return "DATA";
|
2803 | }
|
2804 | if (cp === EOF) {
|
2805 | return "DATA";
|
2806 | }
|
2807 | if (cp === NULL) {
|
2808 | cp = NULL_REPLACEMENT;
|
2809 | }
|
2810 | this.appendTokenValue(cp, null);
|
2811 | cp = this.consumeNextCodePoint();
|
2812 | }
|
2813 | }
|
2814 | MARKUP_DECLARATION_OPEN(cp) {
|
2815 | if (cp === HYPHEN_MINUS && this.text[this.offset + 1] === "-") {
|
2816 | this.offset += 1;
|
2817 | this.column += 1;
|
2818 | this.startToken("HTMLComment");
|
2819 | return "COMMENT_START";
|
2820 | }
|
2821 | if (cp === LATIN_CAPITAL_D &&
|
2822 | this.text.slice(this.offset + 1, this.offset + 7) === "OCTYPE") {
|
2823 | this.startToken("HTMLBogusComment");
|
2824 | this.appendTokenValue(cp, "HTMLBogusComment");
|
2825 | return "BOGUS_COMMENT";
|
2826 | }
|
2827 | if (cp === LEFT_SQUARE_BRACKET &&
|
2828 | this.text.slice(this.offset + 1, this.offset + 7) === "CDATA[") {
|
2829 | this.offset += 6;
|
2830 | this.column += 6;
|
2831 | if (this.namespace === NS.HTML) {
|
2832 | this.reportParseError("cdata-in-html-content");
|
2833 | this.startToken("HTMLBogusComment").value = "[CDATA[";
|
2834 | return "BOGUS_COMMENT";
|
2835 | }
|
2836 | this.startToken("HTMLCDataText");
|
2837 | return "CDATA_SECTION";
|
2838 | }
|
2839 | this.reportParseError("incorrectly-opened-comment");
|
2840 | this.startToken("HTMLBogusComment");
|
2841 | return this.reconsumeAs("BOGUS_COMMENT");
|
2842 | }
|
2843 | COMMENT_START(cp) {
|
2844 | if (cp === HYPHEN_MINUS) {
|
2845 | return "COMMENT_START_DASH";
|
2846 | }
|
2847 | if (cp === GREATER_THAN_SIGN) {
|
2848 | this.reportParseError("abrupt-closing-of-empty-comment");
|
2849 | return "DATA";
|
2850 | }
|
2851 | return this.reconsumeAs("COMMENT");
|
2852 | }
|
2853 | COMMENT_START_DASH(cp) {
|
2854 | if (cp === HYPHEN_MINUS) {
|
2855 | return "COMMENT_END";
|
2856 | }
|
2857 | if (cp === GREATER_THAN_SIGN) {
|
2858 | this.reportParseError("abrupt-closing-of-empty-comment");
|
2859 | return "DATA";
|
2860 | }
|
2861 | if (cp === EOF) {
|
2862 | this.reportParseError("eof-in-comment");
|
2863 | return "DATA";
|
2864 | }
|
2865 | this.appendTokenValue(HYPHEN_MINUS, "HTMLComment");
|
2866 | return this.reconsumeAs("COMMENT");
|
2867 | }
|
2868 | COMMENT(cp) {
|
2869 | while (true) {
|
2870 | if (cp === LESS_THAN_SIGN) {
|
2871 | this.appendTokenValue(LESS_THAN_SIGN, "HTMLComment");
|
2872 | return "COMMENT_LESS_THAN_SIGN";
|
2873 | }
|
2874 | if (cp === HYPHEN_MINUS) {
|
2875 | return "COMMENT_END_DASH";
|
2876 | }
|
2877 | if (cp === NULL) {
|
2878 | this.reportParseError("unexpected-null-character");
|
2879 | cp = NULL_REPLACEMENT;
|
2880 | }
|
2881 | if (cp === EOF) {
|
2882 | this.reportParseError("eof-in-comment");
|
2883 | return "DATA";
|
2884 | }
|
2885 | this.appendTokenValue(cp, "HTMLComment");
|
2886 | cp = this.consumeNextCodePoint();
|
2887 | }
|
2888 | }
|
2889 | COMMENT_LESS_THAN_SIGN(cp) {
|
2890 | while (true) {
|
2891 | if (cp === EXCLAMATION_MARK) {
|
2892 | this.appendTokenValue(cp, "HTMLComment");
|
2893 | return "COMMENT_LESS_THAN_SIGN_BANG";
|
2894 | }
|
2895 | if (cp !== LESS_THAN_SIGN) {
|
2896 | return this.reconsumeAs("COMMENT");
|
2897 | }
|
2898 | this.appendTokenValue(cp, "HTMLComment");
|
2899 | cp = this.consumeNextCodePoint();
|
2900 | }
|
2901 | }
|
2902 | COMMENT_LESS_THAN_SIGN_BANG(cp) {
|
2903 | if (cp === HYPHEN_MINUS) {
|
2904 | return "COMMENT_LESS_THAN_SIGN_BANG_DASH";
|
2905 | }
|
2906 | return this.reconsumeAs("COMMENT");
|
2907 | }
|
2908 | COMMENT_LESS_THAN_SIGN_BANG_DASH(cp) {
|
2909 | if (cp === HYPHEN_MINUS) {
|
2910 | return "COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH";
|
2911 | }
|
2912 | return this.reconsumeAs("COMMENT_END_DASH");
|
2913 | }
|
2914 | COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH(cp) {
|
2915 | if (cp !== GREATER_THAN_SIGN && cp !== EOF) {
|
2916 | this.reportParseError("nested-comment");
|
2917 | }
|
2918 | return this.reconsumeAs("COMMENT_END");
|
2919 | }
|
2920 | COMMENT_END_DASH(cp) {
|
2921 | if (cp === HYPHEN_MINUS) {
|
2922 | return "COMMENT_END";
|
2923 | }
|
2924 | if (cp === EOF) {
|
2925 | this.reportParseError("eof-in-comment");
|
2926 | return "DATA";
|
2927 | }
|
2928 | this.appendTokenValue(HYPHEN_MINUS, "HTMLComment");
|
2929 | return this.reconsumeAs("COMMENT");
|
2930 | }
|
2931 | COMMENT_END(cp) {
|
2932 | while (true) {
|
2933 | if (cp === GREATER_THAN_SIGN) {
|
2934 | return "DATA";
|
2935 | }
|
2936 | if (cp === EXCLAMATION_MARK) {
|
2937 | return "COMMENT_END_BANG";
|
2938 | }
|
2939 | if (cp === EOF) {
|
2940 | this.reportParseError("eof-in-comment");
|
2941 | return "DATA";
|
2942 | }
|
2943 | this.appendTokenValue(HYPHEN_MINUS, "HTMLComment");
|
2944 | if (cp !== HYPHEN_MINUS) {
|
2945 | this.appendTokenValue(HYPHEN_MINUS, "HTMLComment");
|
2946 | return this.reconsumeAs("COMMENT");
|
2947 | }
|
2948 | cp = this.consumeNextCodePoint();
|
2949 | }
|
2950 | }
|
2951 | COMMENT_END_BANG(cp) {
|
2952 | if (cp === HYPHEN_MINUS) {
|
2953 | this.appendTokenValue(HYPHEN_MINUS, "HTMLComment");
|
2954 | this.appendTokenValue(EXCLAMATION_MARK, "HTMLComment");
|
2955 | return "COMMENT_END_DASH";
|
2956 | }
|
2957 | if (cp === GREATER_THAN_SIGN) {
|
2958 | this.reportParseError("incorrectly-closed-comment");
|
2959 | return "DATA";
|
2960 | }
|
2961 | if (cp === EOF) {
|
2962 | this.reportParseError("eof-in-comment");
|
2963 | return "DATA";
|
2964 | }
|
2965 | this.appendTokenValue(HYPHEN_MINUS, "HTMLComment");
|
2966 | this.appendTokenValue(EXCLAMATION_MARK, "HTMLComment");
|
2967 | return this.reconsumeAs("COMMENT");
|
2968 | }
|
2969 | CDATA_SECTION(cp) {
|
2970 | while (true) {
|
2971 | if (cp === RIGHT_SQUARE_BRACKET) {
|
2972 | return "CDATA_SECTION_BRACKET";
|
2973 | }
|
2974 | if (cp === EOF) {
|
2975 | this.reportParseError("eof-in-cdata");
|
2976 | return "DATA";
|
2977 | }
|
2978 | this.appendTokenValue(cp, "HTMLCDataText");
|
2979 | cp = this.consumeNextCodePoint();
|
2980 | }
|
2981 | }
|
2982 | CDATA_SECTION_BRACKET(cp) {
|
2983 | if (cp === RIGHT_SQUARE_BRACKET) {
|
2984 | return "CDATA_SECTION_END";
|
2985 | }
|
2986 | this.appendTokenValue(RIGHT_SQUARE_BRACKET, "HTMLCDataText");
|
2987 | return this.reconsumeAs("CDATA_SECTION");
|
2988 | }
|
2989 | CDATA_SECTION_END(cp) {
|
2990 | while (true) {
|
2991 | if (cp === GREATER_THAN_SIGN) {
|
2992 | return "DATA";
|
2993 | }
|
2994 | if (cp !== RIGHT_SQUARE_BRACKET) {
|
2995 | this.appendTokenValue(RIGHT_SQUARE_BRACKET, "HTMLCDataText");
|
2996 | this.appendTokenValue(RIGHT_SQUARE_BRACKET, "HTMLCDataText");
|
2997 | return this.reconsumeAs("CDATA_SECTION");
|
2998 | }
|
2999 | this.appendTokenValue(RIGHT_SQUARE_BRACKET, "HTMLCDataText");
|
3000 | cp = this.consumeNextCodePoint();
|
3001 | }
|
3002 | }
|
3003 | CHARACTER_REFERENCE(cp) {
|
3004 | this.crStartOffset = this.offset - 1;
|
3005 | this.buffer = [AMPERSAND];
|
3006 | if (isWhitespace(cp) || cp === LESS_THAN_SIGN || cp === EOF) {
|
3007 | return this.reconsumeAs("CHARACTER_REFERENCE_END");
|
3008 | }
|
3009 | if (cp === NUMBER_SIGN) {
|
3010 | this.buffer.push(cp);
|
3011 | return "NUMERIC_CHARACTER_REFERENCE";
|
3012 | }
|
3013 | return this.reconsumeAs("NAMED_CHARACTER_REFERENCE");
|
3014 | }
|
3015 | NAMED_CHARACTER_REFERENCE(cp) {
|
3016 | for (const entitySet of entitySets) {
|
3017 | const length = entitySet.length;
|
3018 | const entities = entitySet.entities;
|
3019 | const text = this.text.slice(this.offset, this.offset + length);
|
3020 | const codepoints = entities[text];
|
3021 | if (codepoints == null) {
|
3022 | continue;
|
3023 | }
|
3024 | const semi = text.endsWith(";");
|
3025 | const next = this.text.codePointAt(this.offset + 1);
|
3026 | this.offset += length - 1;
|
3027 | this.column += length - 1;
|
3028 | if (this.returnState.startsWith("ATTR") &&
|
3029 | !semi &&
|
3030 | next != null &&
|
3031 | (next === EQUALS_SIGN || isLetter(next) || isDigit(next))) {
|
3032 | for (const cp1 of text) {
|
3033 | this.buffer.push(cp1.codePointAt(0));
|
3034 | }
|
3035 | }
|
3036 | else {
|
3037 | if (!semi) {
|
3038 | this.reportParseError("missing-semicolon-after-character-reference");
|
3039 | }
|
3040 | this.buffer = codepoints;
|
3041 | }
|
3042 | return "CHARACTER_REFERENCE_END";
|
3043 | }
|
3044 | for (const cp0 of this.buffer) {
|
3045 | this.appendTokenValue(cp0, null);
|
3046 | }
|
3047 | this.appendTokenValue(cp, null);
|
3048 | return "AMBIGUOUS_AMPERSAND";
|
3049 | }
|
3050 | AMBIGUOUS_AMPERSAND(cp) {
|
3051 | while (isDigit(cp) || isLetter(cp)) {
|
3052 | this.appendTokenValue(cp, null);
|
3053 | cp = this.consumeNextCodePoint();
|
3054 | }
|
3055 | if (cp === SEMICOLON) {
|
3056 | this.reportParseError("unknown-named-character-reference");
|
3057 | }
|
3058 | return this.reconsumeAs(this.returnState);
|
3059 | }
|
3060 | NUMERIC_CHARACTER_REFERENCE(cp) {
|
3061 | this.crCode = 0;
|
3062 | if (cp === LATIN_SMALL_X || cp === LATIN_CAPITAL_X) {
|
3063 | this.buffer.push(cp);
|
3064 | return "HEXADEMICAL_CHARACTER_REFERENCE_START";
|
3065 | }
|
3066 | return this.reconsumeAs("DECIMAL_CHARACTER_REFERENCE_START");
|
3067 | }
|
3068 | HEXADEMICAL_CHARACTER_REFERENCE_START(cp) {
|
3069 | if (isHexDigit(cp)) {
|
3070 | return this.reconsumeAs("HEXADEMICAL_CHARACTER_REFERENCE");
|
3071 | }
|
3072 | this.reportParseError("absence-of-digits-in-numeric-character-reference");
|
3073 | return this.reconsumeAs("CHARACTER_REFERENCE_END");
|
3074 | }
|
3075 | DECIMAL_CHARACTER_REFERENCE_START(cp) {
|
3076 | if (isDigit(cp)) {
|
3077 | return this.reconsumeAs("DECIMAL_CHARACTER_REFERENCE");
|
3078 | }
|
3079 | this.reportParseError("absence-of-digits-in-numeric-character-reference");
|
3080 | return this.reconsumeAs("CHARACTER_REFERENCE_END");
|
3081 | }
|
3082 | HEXADEMICAL_CHARACTER_REFERENCE(cp) {
|
3083 | while (true) {
|
3084 | if (isDigit(cp)) {
|
3085 | this.crCode = 16 * this.crCode + (cp - 0x30);
|
3086 | }
|
3087 | else if (isUpperHexDigit(cp)) {
|
3088 | this.crCode = 16 * this.crCode + (cp - 0x37);
|
3089 | }
|
3090 | else if (isLowerHexDigit(cp)) {
|
3091 | this.crCode = 16 * this.crCode + (cp - 0x57);
|
3092 | }
|
3093 | else {
|
3094 | if (cp === SEMICOLON) {
|
3095 | return "NUMERIC_CHARACTER_REFERENCE_END";
|
3096 | }
|
3097 | this.reportParseError("missing-semicolon-after-character-reference");
|
3098 | return this.reconsumeAs("NUMERIC_CHARACTER_REFERENCE_END");
|
3099 | }
|
3100 | cp = this.consumeNextCodePoint();
|
3101 | }
|
3102 | }
|
3103 | DECIMAL_CHARACTER_REFERENCE(cp) {
|
3104 | while (true) {
|
3105 | if (isDigit(cp)) {
|
3106 | this.crCode = 10 * this.crCode + (cp - 0x30);
|
3107 | }
|
3108 | else {
|
3109 | if (cp === SEMICOLON) {
|
3110 | return "NUMERIC_CHARACTER_REFERENCE_END";
|
3111 | }
|
3112 | this.reportParseError("missing-semicolon-after-character-reference");
|
3113 | return this.reconsumeAs("NUMERIC_CHARACTER_REFERENCE_END");
|
3114 | }
|
3115 | cp = this.consumeNextCodePoint();
|
3116 | }
|
3117 | }
|
3118 | NUMERIC_CHARACTER_REFERENCE_END(_cp) {
|
3119 | let code = this.crCode;
|
3120 | if (code === 0) {
|
3121 | this.reportParseError("null-character-reference");
|
3122 | code = NULL_REPLACEMENT;
|
3123 | }
|
3124 | else if (code > 0x10ffff) {
|
3125 | this.reportParseError("character-reference-outside-unicode-range");
|
3126 | code = NULL_REPLACEMENT;
|
3127 | }
|
3128 | else if (isSurrogate(code)) {
|
3129 | this.reportParseError("surrogate-character-reference");
|
3130 | code = NULL_REPLACEMENT;
|
3131 | }
|
3132 | else if (isNonCharacter(code)) {
|
3133 | this.reportParseError("noncharacter-character-reference");
|
3134 | }
|
3135 | else if (code === 0x0d || (isControl(code) && !isWhitespace(code))) {
|
3136 | this.reportParseError("control-character-reference");
|
3137 | code = alternativeCR.get(code) || code;
|
3138 | }
|
3139 | this.buffer = [code];
|
3140 | return this.reconsumeAs("CHARACTER_REFERENCE_END");
|
3141 | }
|
3142 | CHARACTER_REFERENCE_END(_cp) {
|
3143 | assert(this.currentToken != null);
|
3144 | const token = this.currentToken;
|
3145 | const len0 = token.value.length;
|
3146 | for (const cp1 of this.buffer) {
|
3147 | this.appendTokenValue(cp1, null);
|
3148 | }
|
3149 | const newLength = token.value.length - len0;
|
3150 | for (let i = this.crStartOffset + newLength; i < this.offset; ++i) {
|
3151 | this.gaps.push(i);
|
3152 | }
|
3153 | return this.reconsumeAs(this.returnState);
|
3154 | }
|
3155 | V_EXPRESSION_START(cp) {
|
3156 | if (cp === LEFT_CURLY_BRACKET) {
|
3157 | this.startToken("VExpressionStart");
|
3158 | this.appendTokenValue(LEFT_CURLY_BRACKET, null);
|
3159 | this.appendTokenValue(LEFT_CURLY_BRACKET, null);
|
3160 | return this.returnState;
|
3161 | }
|
3162 | this.appendTokenValue(LEFT_CURLY_BRACKET, null);
|
3163 | return this.reconsumeAs(this.returnState);
|
3164 | }
|
3165 | V_EXPRESSION_END(cp) {
|
3166 | if (cp === RIGHT_CURLY_BRACKET) {
|
3167 | this.startToken("VExpressionEnd");
|
3168 | this.appendTokenValue(RIGHT_CURLY_BRACKET, null);
|
3169 | this.appendTokenValue(RIGHT_CURLY_BRACKET, null);
|
3170 | return this.returnState;
|
3171 | }
|
3172 | this.appendTokenValue(RIGHT_CURLY_BRACKET, null);
|
3173 | return this.reconsumeAs(this.returnState);
|
3174 | }
|
3175 | }
|
3176 |
|
3177 | function getPossibleTypes(parsedSelector) {
|
3178 | switch (parsedSelector.type) {
|
3179 | case "identifier":
|
3180 | return [parsedSelector.value];
|
3181 | case "matches": {
|
3182 | const typesForComponents = parsedSelector.selectors.map(getPossibleTypes);
|
3183 | if (typesForComponents.every(Boolean)) {
|
3184 | return union(...typesForComponents);
|
3185 | }
|
3186 | return null;
|
3187 | }
|
3188 | case "compound": {
|
3189 | const typesForComponents = parsedSelector.selectors.map(getPossibleTypes).filter(Boolean);
|
3190 | if (!typesForComponents.length) {
|
3191 | return null;
|
3192 | }
|
3193 | return intersection(...typesForComponents);
|
3194 | }
|
3195 | case "child":
|
3196 | case "descendant":
|
3197 | case "sibling":
|
3198 | case "adjacent":
|
3199 | return getPossibleTypes(parsedSelector.right);
|
3200 | default:
|
3201 | return null;
|
3202 | }
|
3203 | }
|
3204 | function countClassAttributes(parsedSelector) {
|
3205 | switch (parsedSelector.type) {
|
3206 | case "child":
|
3207 | case "descendant":
|
3208 | case "sibling":
|
3209 | case "adjacent":
|
3210 | return countClassAttributes(parsedSelector.left) + countClassAttributes(parsedSelector.right);
|
3211 | case "compound":
|
3212 | case "not":
|
3213 | case "matches":
|
3214 | return parsedSelector.selectors.reduce((sum, childSelector) => sum + countClassAttributes(childSelector), 0);
|
3215 | case "attribute":
|
3216 | case "field":
|
3217 | case "nth-child":
|
3218 | case "nth-last-child":
|
3219 | return 1;
|
3220 | default:
|
3221 | return 0;
|
3222 | }
|
3223 | }
|
3224 | function countIdentifiers(parsedSelector) {
|
3225 | switch (parsedSelector.type) {
|
3226 | case "child":
|
3227 | case "descendant":
|
3228 | case "sibling":
|
3229 | case "adjacent":
|
3230 | return countIdentifiers(parsedSelector.left) + countIdentifiers(parsedSelector.right);
|
3231 | case "compound":
|
3232 | case "not":
|
3233 | case "matches":
|
3234 | return parsedSelector.selectors.reduce((sum, childSelector) => sum + countIdentifiers(childSelector), 0);
|
3235 | case "identifier":
|
3236 | return 1;
|
3237 | default:
|
3238 | return 0;
|
3239 | }
|
3240 | }
|
3241 | function compareSpecificity(selectorA, selectorB) {
|
3242 | return selectorA.attributeCount - selectorB.attributeCount ||
|
3243 | selectorA.identifierCount - selectorB.identifierCount ||
|
3244 | (selectorA.rawSelector <= selectorB.rawSelector ? -1 : 1);
|
3245 | }
|
3246 | function tryParseSelector(rawSelector) {
|
3247 | try {
|
3248 | return esquery.parse(rawSelector.replace(/:exit$/, ""));
|
3249 | }
|
3250 | catch (err) {
|
3251 | if (typeof err.offset === "number") {
|
3252 | throw new Error(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);
|
3253 | }
|
3254 | throw err;
|
3255 | }
|
3256 | }
|
3257 | const parseSelector = memoize(rawSelector => {
|
3258 | const parsedSelector = tryParseSelector(rawSelector);
|
3259 | return {
|
3260 | rawSelector,
|
3261 | isExit: rawSelector.endsWith(":exit"),
|
3262 | parsedSelector,
|
3263 | listenerTypes: getPossibleTypes(parsedSelector),
|
3264 | attributeCount: countClassAttributes(parsedSelector),
|
3265 | identifierCount: countIdentifiers(parsedSelector),
|
3266 | };
|
3267 | });
|
3268 | class NodeEventGenerator {
|
3269 | constructor(emitter) {
|
3270 | this.emitter = emitter;
|
3271 | this.currentAncestry = [];
|
3272 | this.enterSelectorsByNodeType = new Map();
|
3273 | this.exitSelectorsByNodeType = new Map();
|
3274 | this.anyTypeEnterSelectors = [];
|
3275 | this.anyTypeExitSelectors = [];
|
3276 | const eventNames = typeof emitter.eventNames === "function"
|
3277 | ? emitter.eventNames()
|
3278 | : Object.keys(emitter._events);
|
3279 | for (const rawSelector of eventNames) {
|
3280 | if (typeof rawSelector === "symbol") {
|
3281 | continue;
|
3282 | }
|
3283 | const selector = parseSelector(rawSelector);
|
3284 | if (selector.listenerTypes) {
|
3285 | for (const nodeType of selector.listenerTypes) {
|
3286 | const typeMap = selector.isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType;
|
3287 | let selectors = typeMap.get(nodeType);
|
3288 | if (selectors == null) {
|
3289 | typeMap.set(nodeType, (selectors = []));
|
3290 | }
|
3291 | selectors.push(selector);
|
3292 | }
|
3293 | }
|
3294 | else {
|
3295 | (selector.isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors).push(selector);
|
3296 | }
|
3297 | }
|
3298 | this.anyTypeEnterSelectors.sort(compareSpecificity);
|
3299 | this.anyTypeExitSelectors.sort(compareSpecificity);
|
3300 | for (const selectorList of this.enterSelectorsByNodeType.values()) {
|
3301 | selectorList.sort(compareSpecificity);
|
3302 | }
|
3303 | for (const selectorList of this.exitSelectorsByNodeType.values()) {
|
3304 | selectorList.sort(compareSpecificity);
|
3305 | }
|
3306 | }
|
3307 | applySelector(node, selector) {
|
3308 | if (esquery.matches(node, selector.parsedSelector, this.currentAncestry)) {
|
3309 | this.emitter.emit(selector.rawSelector, node);
|
3310 | }
|
3311 | }
|
3312 | applySelectors(node, isExit) {
|
3313 | const selectorsByNodeType = (isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType).get(node.type) || [];
|
3314 | const anyTypeSelectors = isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors;
|
3315 | let selectorsByTypeIndex = 0;
|
3316 | let anyTypeSelectorsIndex = 0;
|
3317 | while (selectorsByTypeIndex < selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length) {
|
3318 | if (selectorsByTypeIndex >= selectorsByNodeType.length ||
|
3319 | (anyTypeSelectorsIndex < anyTypeSelectors.length && compareSpecificity(anyTypeSelectors[anyTypeSelectorsIndex], selectorsByNodeType[selectorsByTypeIndex]) < 0)) {
|
3320 | this.applySelector(node, anyTypeSelectors[anyTypeSelectorsIndex++]);
|
3321 | }
|
3322 | else {
|
3323 | this.applySelector(node, selectorsByNodeType[selectorsByTypeIndex++]);
|
3324 | }
|
3325 | }
|
3326 | }
|
3327 | enterNode(node) {
|
3328 | if (node.parent) {
|
3329 | this.currentAncestry.unshift(node.parent);
|
3330 | }
|
3331 | this.applySelectors(node, false);
|
3332 | }
|
3333 | leaveNode(node) {
|
3334 | this.applySelectors(node, true);
|
3335 | this.currentAncestry.shift();
|
3336 | }
|
3337 | }
|
3338 |
|
3339 | function getStartLocation(token) {
|
3340 | return token.range[0];
|
3341 | }
|
3342 | function search(tokens, location) {
|
3343 | return sortedIndexBy(tokens, { range: [location] }, getStartLocation);
|
3344 | }
|
3345 | function getFirstIndex(tokens, indexMap, startLoc) {
|
3346 | if (startLoc in indexMap) {
|
3347 | return indexMap[startLoc];
|
3348 | }
|
3349 | if ((startLoc - 1) in indexMap) {
|
3350 | const index = indexMap[startLoc - 1];
|
3351 | const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;
|
3352 | if (token && token.range[0] >= startLoc) {
|
3353 | return index;
|
3354 | }
|
3355 | return index + 1;
|
3356 | }
|
3357 | return 0;
|
3358 | }
|
3359 | function getLastIndex(tokens, indexMap, endLoc) {
|
3360 | if (endLoc in indexMap) {
|
3361 | return indexMap[endLoc] - 1;
|
3362 | }
|
3363 | if ((endLoc - 1) in indexMap) {
|
3364 | const index = indexMap[endLoc - 1];
|
3365 | const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;
|
3366 | if (token && token.range[1] > endLoc) {
|
3367 | return index - 1;
|
3368 | }
|
3369 | return index;
|
3370 | }
|
3371 | return tokens.length - 1;
|
3372 | }
|
3373 |
|
3374 | class Cursor {
|
3375 | constructor() {
|
3376 | this.current = null;
|
3377 | }
|
3378 | getOneToken() {
|
3379 | return this.moveNext() ? this.current : null;
|
3380 | }
|
3381 | getAllTokens() {
|
3382 | const tokens = [];
|
3383 | while (this.moveNext()) {
|
3384 | tokens.push(this.current);
|
3385 | }
|
3386 | return tokens;
|
3387 | }
|
3388 | }
|
3389 |
|
3390 | class BackwardTokenCommentCursor extends Cursor {
|
3391 | constructor(tokens, comments, indexMap, startLoc, endLoc) {
|
3392 | super();
|
3393 | this.tokens = tokens;
|
3394 | this.comments = comments;
|
3395 | this.tokenIndex = getLastIndex(tokens, indexMap, endLoc);
|
3396 | this.commentIndex = search(comments, endLoc) - 1;
|
3397 | this.border = startLoc;
|
3398 | }
|
3399 | moveNext() {
|
3400 | const token = (this.tokenIndex >= 0) ? this.tokens[this.tokenIndex] : null;
|
3401 | const comment = (this.commentIndex >= 0) ? this.comments[this.commentIndex] : null;
|
3402 | if (token && (!comment || token.range[1] > comment.range[1])) {
|
3403 | this.current = token;
|
3404 | this.tokenIndex -= 1;
|
3405 | }
|
3406 | else if (comment) {
|
3407 | this.current = comment;
|
3408 | this.commentIndex -= 1;
|
3409 | }
|
3410 | else {
|
3411 | this.current = null;
|
3412 | }
|
3413 | return this.current != null && (this.border === -1 || this.current.range[0] >= this.border);
|
3414 | }
|
3415 | }
|
3416 |
|
3417 | class BackwardTokenCursor extends Cursor {
|
3418 | constructor(tokens, _comments, indexMap, startLoc, endLoc) {
|
3419 | super();
|
3420 | this.tokens = tokens;
|
3421 | this.index = getLastIndex(tokens, indexMap, endLoc);
|
3422 | this.indexEnd = getFirstIndex(tokens, indexMap, startLoc);
|
3423 | }
|
3424 | moveNext() {
|
3425 | if (this.index >= this.indexEnd) {
|
3426 | this.current = this.tokens[this.index];
|
3427 | this.index -= 1;
|
3428 | return true;
|
3429 | }
|
3430 | return false;
|
3431 | }
|
3432 | getOneToken() {
|
3433 | return (this.index >= this.indexEnd) ? this.tokens[this.index] : null;
|
3434 | }
|
3435 | }
|
3436 |
|
3437 | class DecorativeCursor extends Cursor {
|
3438 | constructor(cursor) {
|
3439 | super();
|
3440 | this.cursor = cursor;
|
3441 | }
|
3442 | moveNext() {
|
3443 | const retv = this.cursor.moveNext();
|
3444 | this.current = this.cursor.current;
|
3445 | return retv;
|
3446 | }
|
3447 | }
|
3448 |
|
3449 | class FilterCursor extends DecorativeCursor {
|
3450 | constructor(cursor, predicate) {
|
3451 | super(cursor);
|
3452 | this.predicate = predicate;
|
3453 | }
|
3454 | moveNext() {
|
3455 | const predicate = this.predicate;
|
3456 | while (super.moveNext()) {
|
3457 | if (predicate(this.current)) {
|
3458 | return true;
|
3459 | }
|
3460 | }
|
3461 | return false;
|
3462 | }
|
3463 | }
|
3464 |
|
3465 | class ForwardTokenCommentCursor extends Cursor {
|
3466 | constructor(tokens, comments, indexMap, startLoc, endLoc) {
|
3467 | super();
|
3468 | this.tokens = tokens;
|
3469 | this.comments = comments;
|
3470 | this.tokenIndex = getFirstIndex(tokens, indexMap, startLoc);
|
3471 | this.commentIndex = search(comments, startLoc);
|
3472 | this.border = endLoc;
|
3473 | }
|
3474 | moveNext() {
|
3475 | const token = (this.tokenIndex < this.tokens.length) ? this.tokens[this.tokenIndex] : null;
|
3476 | const comment = (this.commentIndex < this.comments.length) ? this.comments[this.commentIndex] : null;
|
3477 | if (token && (!comment || token.range[0] < comment.range[0])) {
|
3478 | this.current = token;
|
3479 | this.tokenIndex += 1;
|
3480 | }
|
3481 | else if (comment) {
|
3482 | this.current = comment;
|
3483 | this.commentIndex += 1;
|
3484 | }
|
3485 | else {
|
3486 | this.current = null;
|
3487 | }
|
3488 | return this.current != null && (this.border === -1 || this.current.range[1] <= this.border);
|
3489 | }
|
3490 | }
|
3491 |
|
3492 | class ForwardTokenCursor extends Cursor {
|
3493 | constructor(tokens, _comments, indexMap, startLoc, endLoc) {
|
3494 | super();
|
3495 | this.tokens = tokens;
|
3496 | this.index = getFirstIndex(tokens, indexMap, startLoc);
|
3497 | this.indexEnd = getLastIndex(tokens, indexMap, endLoc);
|
3498 | }
|
3499 | moveNext() {
|
3500 | if (this.index <= this.indexEnd) {
|
3501 | this.current = this.tokens[this.index];
|
3502 | this.index += 1;
|
3503 | return true;
|
3504 | }
|
3505 | return false;
|
3506 | }
|
3507 | getOneToken() {
|
3508 | return (this.index <= this.indexEnd) ? this.tokens[this.index] : null;
|
3509 | }
|
3510 | getAllTokens() {
|
3511 | return this.tokens.slice(this.index, this.indexEnd + 1);
|
3512 | }
|
3513 | }
|
3514 |
|
3515 | class LimitCursor extends DecorativeCursor {
|
3516 | constructor(cursor, count) {
|
3517 | super(cursor);
|
3518 | this.count = count;
|
3519 | }
|
3520 | moveNext() {
|
3521 | if (this.count > 0) {
|
3522 | this.count -= 1;
|
3523 | return super.moveNext();
|
3524 | }
|
3525 | return false;
|
3526 | }
|
3527 | }
|
3528 |
|
3529 | class SkipCursor extends DecorativeCursor {
|
3530 | constructor(cursor, count) {
|
3531 | super(cursor);
|
3532 | this.count = count;
|
3533 | }
|
3534 | moveNext() {
|
3535 | while (this.count > 0) {
|
3536 | this.count -= 1;
|
3537 | if (!super.moveNext()) {
|
3538 | return false;
|
3539 | }
|
3540 | }
|
3541 | return super.moveNext();
|
3542 | }
|
3543 | }
|
3544 |
|
3545 | class CursorFactory {
|
3546 | constructor(TokenCursor, TokenCommentCursor) {
|
3547 | this.TokenCursor = TokenCursor;
|
3548 | this.TokenCommentCursor = TokenCommentCursor;
|
3549 | }
|
3550 | createBaseCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments) {
|
3551 | const TokenCursor = includeComments ? this.TokenCommentCursor : this.TokenCursor;
|
3552 | return new TokenCursor(tokens, comments, indexMap, startLoc, endLoc);
|
3553 | }
|
3554 | createCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments, filter, skip, count) {
|
3555 | let cursor = this.createBaseCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments);
|
3556 | if (filter) {
|
3557 | cursor = new FilterCursor(cursor, filter);
|
3558 | }
|
3559 | if (skip >= 1) {
|
3560 | cursor = new SkipCursor(cursor, skip);
|
3561 | }
|
3562 | if (count >= 0) {
|
3563 | cursor = new LimitCursor(cursor, count);
|
3564 | }
|
3565 | return cursor;
|
3566 | }
|
3567 | }
|
3568 | const forward = new CursorFactory(ForwardTokenCursor, ForwardTokenCommentCursor);
|
3569 | const backward = new CursorFactory(BackwardTokenCursor, BackwardTokenCommentCursor);
|
3570 |
|
3571 | class PaddedTokenCursor extends ForwardTokenCursor {
|
3572 | constructor(tokens, comments, indexMap, startLoc, endLoc, beforeCount, afterCount) {
|
3573 | super(tokens, comments, indexMap, startLoc, endLoc);
|
3574 | this.index = Math.max(0, this.index - beforeCount);
|
3575 | this.indexEnd = Math.min(tokens.length - 1, this.indexEnd + afterCount);
|
3576 | }
|
3577 | }
|
3578 |
|
3579 | function isCommentToken(token) {
|
3580 | return token.type === "Line" || token.type === "Block" || token.type === "Shebang";
|
3581 | }
|
3582 | function createIndexMap(tokens, comments) {
|
3583 | const map = Object.create(null);
|
3584 | let tokenIndex = 0;
|
3585 | let commentIndex = 0;
|
3586 | let nextStart = 0;
|
3587 | let range = null;
|
3588 | while (tokenIndex < tokens.length || commentIndex < comments.length) {
|
3589 | nextStart = (commentIndex < comments.length) ? comments[commentIndex].range[0] : Number.MAX_SAFE_INTEGER;
|
3590 | while (tokenIndex < tokens.length && (range = tokens[tokenIndex].range)[0] < nextStart) {
|
3591 | map[range[0]] = tokenIndex;
|
3592 | map[range[1] - 1] = tokenIndex;
|
3593 | tokenIndex += 1;
|
3594 | }
|
3595 | nextStart = (tokenIndex < tokens.length) ? tokens[tokenIndex].range[0] : Number.MAX_SAFE_INTEGER;
|
3596 | while (commentIndex < comments.length && (range = comments[commentIndex].range)[0] < nextStart) {
|
3597 | map[range[0]] = tokenIndex;
|
3598 | map[range[1] - 1] = tokenIndex;
|
3599 | commentIndex += 1;
|
3600 | }
|
3601 | }
|
3602 | return map;
|
3603 | }
|
3604 | function createCursorWithSkip(factory, tokens, comments, indexMap, startLoc, endLoc, opts) {
|
3605 | let includeComments = false;
|
3606 | let skip = 0;
|
3607 | let filter = null;
|
3608 | if (typeof opts === "number") {
|
3609 | skip = opts | 0;
|
3610 | }
|
3611 | else if (typeof opts === "function") {
|
3612 | filter = opts;
|
3613 | }
|
3614 | else if (opts) {
|
3615 | includeComments = Boolean(opts.includeComments);
|
3616 | skip = opts.skip || 0;
|
3617 | filter = opts.filter || null;
|
3618 | }
|
3619 | assert(skip >= 0, "options.skip should be zero or a positive integer.");
|
3620 | assert(!filter || typeof filter === "function", "options.filter should be a function.");
|
3621 | return factory.createCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments, filter, skip, -1);
|
3622 | }
|
3623 | function createCursorWithCount(factory, tokens, comments, indexMap, startLoc, endLoc, opts) {
|
3624 | let includeComments = false;
|
3625 | let count = 0;
|
3626 | let countExists = false;
|
3627 | let filter = null;
|
3628 | if (typeof opts === "number") {
|
3629 | count = opts | 0;
|
3630 | countExists = true;
|
3631 | }
|
3632 | else if (typeof opts === "function") {
|
3633 | filter = opts;
|
3634 | }
|
3635 | else if (opts) {
|
3636 | includeComments = Boolean(opts.includeComments);
|
3637 | count = opts.count || 0;
|
3638 | countExists = typeof opts.count === "number";
|
3639 | filter = opts.filter || null;
|
3640 | }
|
3641 | assert(count >= 0, "options.count should be zero or a positive integer.");
|
3642 | assert(!filter || typeof filter === "function", "options.filter should be a function.");
|
3643 | return factory.createCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments, filter, 0, countExists ? count : -1);
|
3644 | }
|
3645 | function createCursorWithPadding(tokens, comments, indexMap, startLoc, endLoc, beforeCount, afterCount) {
|
3646 | if (typeof beforeCount === "undefined" && typeof afterCount === "undefined") {
|
3647 | return new ForwardTokenCursor(tokens, comments, indexMap, startLoc, endLoc);
|
3648 | }
|
3649 | if (typeof beforeCount === "number" || typeof beforeCount === "undefined") {
|
3650 | return new PaddedTokenCursor(tokens, comments, indexMap, startLoc, endLoc, beforeCount || 0, afterCount || 0);
|
3651 | }
|
3652 | return createCursorWithCount(forward, tokens, comments, indexMap, startLoc, endLoc, beforeCount);
|
3653 | }
|
3654 | function getAdjacentCommentTokensFromCursor(cursor) {
|
3655 | const tokens = [];
|
3656 | let currentToken = cursor.getOneToken();
|
3657 | while (currentToken && isCommentToken(currentToken)) {
|
3658 | tokens.push(currentToken);
|
3659 | currentToken = cursor.getOneToken();
|
3660 | }
|
3661 | return tokens;
|
3662 | }
|
3663 | class TokenStore {
|
3664 | constructor(tokens, comments) {
|
3665 | this._tokens = tokens;
|
3666 | this._comments = comments;
|
3667 | this._indexMap = createIndexMap(tokens, comments);
|
3668 | }
|
3669 | getTokenByRangeStart(offset, options) {
|
3670 | const includeComments = Boolean(options && options.includeComments);
|
3671 | const token = forward.createBaseCursor(this._tokens, this._comments, this._indexMap, offset, -1, includeComments).getOneToken();
|
3672 | if (token && token.range[0] === offset) {
|
3673 | return token;
|
3674 | }
|
3675 | return null;
|
3676 | }
|
3677 | getFirstToken(node, options) {
|
3678 | return createCursorWithSkip(forward, this._tokens, this._comments, this._indexMap, node.range[0], node.range[1], options).getOneToken();
|
3679 | }
|
3680 | getLastToken(node, options) {
|
3681 | return createCursorWithSkip(backward, this._tokens, this._comments, this._indexMap, node.range[0], node.range[1], options).getOneToken();
|
3682 | }
|
3683 | getTokenBefore(node, options) {
|
3684 | return createCursorWithSkip(backward, this._tokens, this._comments, this._indexMap, -1, node.range[0], options).getOneToken();
|
3685 | }
|
3686 | getTokenAfter(node, options) {
|
3687 | return createCursorWithSkip(forward, this._tokens, this._comments, this._indexMap, node.range[1], -1, options).getOneToken();
|
3688 | }
|
3689 | getFirstTokenBetween(left, right, options) {
|
3690 | return createCursorWithSkip(forward, this._tokens, this._comments, this._indexMap, left.range[1], right.range[0], options).getOneToken();
|
3691 | }
|
3692 | getLastTokenBetween(left, right, options) {
|
3693 | return createCursorWithSkip(backward, this._tokens, this._comments, this._indexMap, left.range[1], right.range[0], options).getOneToken();
|
3694 | }
|
3695 | getTokenOrCommentBefore(node, skip) {
|
3696 | return this.getTokenBefore(node, { includeComments: true, skip });
|
3697 | }
|
3698 | getTokenOrCommentAfter(node, skip) {
|
3699 | return this.getTokenAfter(node, { includeComments: true, skip });
|
3700 | }
|
3701 | getFirstTokens(node, options) {
|
3702 | return createCursorWithCount(forward, this._tokens, this._comments, this._indexMap, node.range[0], node.range[1], options).getAllTokens();
|
3703 | }
|
3704 | getLastTokens(node, options) {
|
3705 | return createCursorWithCount(backward, this._tokens, this._comments, this._indexMap, node.range[0], node.range[1], options).getAllTokens().reverse();
|
3706 | }
|
3707 | getTokensBefore(node, options) {
|
3708 | return createCursorWithCount(backward, this._tokens, this._comments, this._indexMap, -1, node.range[0], options).getAllTokens().reverse();
|
3709 | }
|
3710 | getTokensAfter(node, options) {
|
3711 | return createCursorWithCount(forward, this._tokens, this._comments, this._indexMap, node.range[1], -1, options).getAllTokens();
|
3712 | }
|
3713 | getFirstTokensBetween(left, right, options) {
|
3714 | return createCursorWithCount(forward, this._tokens, this._comments, this._indexMap, left.range[1], right.range[0], options).getAllTokens();
|
3715 | }
|
3716 | getLastTokensBetween(left, right, options) {
|
3717 | return createCursorWithCount(backward, this._tokens, this._comments, this._indexMap, left.range[1], right.range[0], options).getAllTokens().reverse();
|
3718 | }
|
3719 | getTokens(node, beforeCount, afterCount) {
|
3720 | return createCursorWithPadding(this._tokens, this._comments, this._indexMap, node.range[0], node.range[1], beforeCount, afterCount).getAllTokens();
|
3721 | }
|
3722 | getTokensBetween(left, right, padding) {
|
3723 | return createCursorWithPadding(this._tokens, this._comments, this._indexMap, left.range[1], right.range[0], padding, typeof padding === "number" ? padding : undefined).getAllTokens();
|
3724 | }
|
3725 | commentsExistBetween(left, right) {
|
3726 | const index = search(this._comments, left.range[1]);
|
3727 | return (index < this._comments.length &&
|
3728 | this._comments[index].range[1] <= right.range[0]);
|
3729 | }
|
3730 | getCommentsBefore(nodeOrToken) {
|
3731 | const cursor = createCursorWithCount(backward, this._tokens, this._comments, this._indexMap, -1, nodeOrToken.range[0], { includeComments: true });
|
3732 | return getAdjacentCommentTokensFromCursor(cursor).reverse();
|
3733 | }
|
3734 | getCommentsAfter(nodeOrToken) {
|
3735 | const cursor = createCursorWithCount(forward, this._tokens, this._comments, this._indexMap, nodeOrToken.range[1], -1, { includeComments: true });
|
3736 | return getAdjacentCommentTokensFromCursor(cursor);
|
3737 | }
|
3738 | getCommentsInside(node) {
|
3739 | return this.getTokens(node, {
|
3740 | includeComments: true,
|
3741 | filter: isCommentToken,
|
3742 | });
|
3743 | }
|
3744 | }
|
3745 |
|
3746 | const emitters = new WeakMap();
|
3747 | const stores = new WeakMap();
|
3748 | function define(rootAST, document) {
|
3749 | return {
|
3750 | defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor) {
|
3751 | if (scriptVisitor == null) {
|
3752 | scriptVisitor = {};
|
3753 | }
|
3754 | if (rootAST.templateBody == null) {
|
3755 | return scriptVisitor;
|
3756 | }
|
3757 | let emitter = emitters.get(rootAST);
|
3758 | if (emitter == null) {
|
3759 | emitter = new EventEmitter();
|
3760 | emitter.setMaxListeners(0);
|
3761 | emitters.set(rootAST, emitter);
|
3762 | const programExitHandler = scriptVisitor["Program:exit"];
|
3763 | scriptVisitor["Program:exit"] = node => {
|
3764 | try {
|
3765 | if (typeof programExitHandler === "function") {
|
3766 | programExitHandler(node);
|
3767 | }
|
3768 | const generator = new NodeEventGenerator(emitter);
|
3769 | traverseNodes(rootAST.templateBody, generator);
|
3770 | }
|
3771 | finally {
|
3772 | scriptVisitor["Program:exit"] = programExitHandler;
|
3773 | emitters.delete(rootAST);
|
3774 | }
|
3775 | };
|
3776 | }
|
3777 | for (const selector of Object.keys(templateBodyVisitor)) {
|
3778 | emitter.on(selector, templateBodyVisitor[selector]);
|
3779 | }
|
3780 | return scriptVisitor;
|
3781 | },
|
3782 | getTemplateBodyTokenStore() {
|
3783 | const ast = rootAST.templateBody;
|
3784 | const key = ast || stores;
|
3785 | let store = stores.get(key);
|
3786 | if (!store) {
|
3787 | store =
|
3788 | ast != null
|
3789 | ? new TokenStore(ast.tokens, ast.comments)
|
3790 | : new TokenStore([], []);
|
3791 | stores.set(key, store);
|
3792 | }
|
3793 | return store;
|
3794 | },
|
3795 | getDocumentFragment() {
|
3796 | return document;
|
3797 | },
|
3798 | };
|
3799 | }
|
3800 |
|
3801 | const STARTS_WITH_LT = /^\s*</u;
|
3802 | function isVueFile(code, options) {
|
3803 | const filePath = options.filePath || "unknown.js";
|
3804 | return path.extname(filePath) === ".vue" || STARTS_WITH_LT.test(code);
|
3805 | }
|
3806 | function isTemplateElement(node) {
|
3807 | return node.type === "VElement" && node.name === "template";
|
3808 | }
|
3809 | function isScriptElement(node) {
|
3810 | return node.type === "VElement" && node.name === "script";
|
3811 | }
|
3812 | function isLang(attribute) {
|
3813 | return attribute.directive === false && attribute.key.name === "lang";
|
3814 | }
|
3815 | function getLang(element, defaultLang) {
|
3816 | const langAttr = element && element.startTag.attributes.find(isLang);
|
3817 | const lang = langAttr && langAttr.value && langAttr.value.value;
|
3818 | return lang || defaultLang;
|
3819 | }
|
3820 | function parseForESLint(code, options) {
|
3821 | options = Object.assign({
|
3822 | comment: true,
|
3823 | ecmaVersion: 2015,
|
3824 | loc: true,
|
3825 | range: true,
|
3826 | tokens: true,
|
3827 | }, options || {});
|
3828 | let result;
|
3829 | let document;
|
3830 | if (!isVueFile(code, options)) {
|
3831 | result = parseScript(code, options);
|
3832 | document = null;
|
3833 | }
|
3834 | else {
|
3835 | const skipParsingScript = options.parser === false;
|
3836 | const tokenizer = new Tokenizer(code);
|
3837 | const rootAST = new Parser(tokenizer, options).parse();
|
3838 | const locationCalcurator = new LocationCalculator(tokenizer.gaps, tokenizer.lineTerminators);
|
3839 | const script = rootAST.children.find(isScriptElement);
|
3840 | const template = rootAST.children.find(isTemplateElement);
|
3841 | const templateLang = getLang(template, "html");
|
3842 | const concreteInfo = {
|
3843 | tokens: rootAST.tokens,
|
3844 | comments: rootAST.comments,
|
3845 | errors: rootAST.errors,
|
3846 | };
|
3847 | const templateBody = template != null && templateLang === "html"
|
3848 | ? Object.assign(template, concreteInfo)
|
3849 | : undefined;
|
3850 | if (skipParsingScript || script == null) {
|
3851 | result = parseScript("", options);
|
3852 | }
|
3853 | else {
|
3854 | result = parseScriptElement(script, locationCalcurator, options);
|
3855 | }
|
3856 | result.ast.templateBody = templateBody;
|
3857 | document = rootAST;
|
3858 | }
|
3859 | result.services = Object.assign(result.services || {}, define(result.ast, document));
|
3860 | return result;
|
3861 | }
|
3862 | function parse(code, options) {
|
3863 | return parseForESLint(code, options).ast;
|
3864 | }
|
3865 |
|
3866 | exports.AST = index;
|
3867 | exports.parse = parse;
|
3868 | exports.parseForESLint = parseForESLint;
|
3869 |
|