1 | (function (global, factory) {
|
2 | typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/compiler'), require('@angular/compiler-cli'), require('typescript')) :
|
3 | typeof define === 'function' && define.amd ? define(['exports', '@angular/core', '@angular/compiler', '@angular/compiler-cli', 'typescript'], factory) :
|
4 | (factory((global.ngast = global.ngast || {}),global._angular_core,global._angular_compiler,global._angular_compilerCli,global.ts));
|
5 | }(this, (function (exports,_angular_core,_angular_compiler,_angular_compilerCli,ts) { 'use strict';
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 | var Symbol = (function () {
|
15 | |
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 | function Symbol(_program, _symbol) {
|
24 | this._program = _program;
|
25 | this._symbol = _symbol;
|
26 | }
|
27 | |
28 |
|
29 |
|
30 |
|
31 |
|
32 |
|
33 |
|
34 |
|
35 | Symbol.prototype.getNode = function () {
|
36 | var _this = this;
|
37 | var program = this._program.getSourceFile(this._symbol.filePath);
|
38 | var findNode = function (node) {
|
39 | if (node.kind === ts.SyntaxKind.ClassDeclaration &&
|
40 | (node.name || { text: undefined }).text === _this._symbol.name) {
|
41 | return node;
|
42 | }
|
43 | else {
|
44 | return ts.forEachChild(node, findNode);
|
45 | }
|
46 | };
|
47 | return findNode(program);
|
48 | };
|
49 | Object.defineProperty(Symbol.prototype, "symbol", {
|
50 | |
51 |
|
52 |
|
53 |
|
54 |
|
55 |
|
56 |
|
57 | get: function () {
|
58 | return this._symbol;
|
59 | },
|
60 | enumerable: true,
|
61 | configurable: true
|
62 | });
|
63 | return Symbol;
|
64 | }());
|
65 |
|
66 | var __extends$1 = (undefined && undefined.__extends) || (function () {
|
67 | var extendStatics = Object.setPrototypeOf ||
|
68 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
69 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
70 | return function (d, b) {
|
71 | extendStatics(d, b);
|
72 | function __() { this.constructor = d; }
|
73 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
74 | };
|
75 | })();
|
76 | var ProviderSymbol = (function (_super) {
|
77 | __extends$1(ProviderSymbol, _super);
|
78 | function ProviderSymbol(program, provider, metadataResolver) {
|
79 | var _this = _super.call(this, program, provider.token.identifier.reference) || this;
|
80 | _this.provider = provider;
|
81 | _this.metadataResolver = metadataResolver;
|
82 | return _this;
|
83 | }
|
84 | |
85 |
|
86 |
|
87 | ProviderSymbol.prototype.getMetadata = function () {
|
88 | return this.provider;
|
89 | };
|
90 | |
91 |
|
92 |
|
93 | ProviderSymbol.prototype.getDependencies = function () {
|
94 | var _this = this;
|
95 | return (this.provider.deps || []).map(function (d) {
|
96 | var meta = new _angular_compiler.ProviderMeta(d.token.identifier.reference, d);
|
97 | return new ProviderSymbol(_this._program, _this.metadataResolver.getProviderMetadata(meta), _this.metadataResolver);
|
98 | });
|
99 | };
|
100 | return ProviderSymbol;
|
101 | }(Symbol));
|
102 |
|
103 | var __extends = (undefined && undefined.__extends) || (function () {
|
104 | var extendStatics = Object.setPrototypeOf ||
|
105 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
106 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
107 | return function (d, b) {
|
108 | extendStatics(d, b);
|
109 | function __() { this.constructor = d; }
|
110 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
111 | };
|
112 | })();
|
113 |
|
114 |
|
115 |
|
116 |
|
117 |
|
118 |
|
119 |
|
120 | var PipeSymbol = (function (_super) {
|
121 | __extends(PipeSymbol, _super);
|
122 | |
123 |
|
124 |
|
125 |
|
126 |
|
127 |
|
128 |
|
129 |
|
130 |
|
131 |
|
132 | function PipeSymbol(program, symbol, resolver, metadataResolver, projectSymbols) {
|
133 | var _this = _super.call(this, program, symbol) || this;
|
134 | _this.resolver = resolver;
|
135 | _this.metadataResolver = metadataResolver;
|
136 | _this.projectSymbols = projectSymbols;
|
137 | return _this;
|
138 | }
|
139 | |
140 |
|
141 |
|
142 |
|
143 |
|
144 |
|
145 |
|
146 | PipeSymbol.prototype.getModule = function () {
|
147 | return this.projectSymbols.getAnalyzedModules()
|
148 | .ngModuleByPipeOrDirective.get(this.symbol);
|
149 | };
|
150 | |
151 |
|
152 |
|
153 |
|
154 |
|
155 |
|
156 |
|
157 | PipeSymbol.prototype.getMetadata = function () {
|
158 | return this.resolver.resolve(_angular_core.resolveForwardRef(this.symbol));
|
159 | };
|
160 | PipeSymbol.prototype.getDependencies = function () {
|
161 | var _this = this;
|
162 | var summary = this.metadataResolver.getInjectableSummary(this.symbol);
|
163 | if (!summary) {
|
164 | return [];
|
165 | }
|
166 | else {
|
167 | return (summary.type.diDeps || []).map(function (d) {
|
168 | var meta = new _angular_compiler.ProviderMeta(d.token.identifier.reference, d);
|
169 | return new ProviderSymbol(_this._program, _this.metadataResolver.getProviderMetadata(meta), _this.metadataResolver);
|
170 | });
|
171 | }
|
172 | };
|
173 | return PipeSymbol;
|
174 | }(Symbol));
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 | var $EOF = 0;
|
190 | var $TAB = 9;
|
191 | var $LF = 10;
|
192 | var $VTAB = 11;
|
193 | var $FF = 12;
|
194 | var $CR = 13;
|
195 | var $SPACE = 32;
|
196 | var $BANG = 33;
|
197 | var $DQ = 34;
|
198 | var $HASH = 35;
|
199 | var $$ = 36;
|
200 | var $PERCENT = 37;
|
201 | var $AMPERSAND = 38;
|
202 | var $SQ = 39;
|
203 | var $LPAREN = 40;
|
204 | var $RPAREN = 41;
|
205 | var $STAR = 42;
|
206 | var $PLUS = 43;
|
207 | var $COMMA = 44;
|
208 | var $MINUS = 45;
|
209 | var $PERIOD = 46;
|
210 | var $SLASH = 47;
|
211 | var $COLON = 58;
|
212 | var $SEMICOLON = 59;
|
213 |
|
214 | var $EQ = 61;
|
215 | var $GT = 62;
|
216 | var $QUESTION = 63;
|
217 | var $0 = 48;
|
218 | var $9 = 57;
|
219 | var $A = 65;
|
220 |
|
221 |
|
222 |
|
223 | var $Z = 90;
|
224 | var $LBRACKET = 91;
|
225 | var $BACKSLASH = 92;
|
226 | var $RBRACKET = 93;
|
227 | var $CARET = 94;
|
228 | var $_ = 95;
|
229 | var $a = 97;
|
230 |
|
231 |
|
232 |
|
233 |
|
234 |
|
235 |
|
236 |
|
237 |
|
238 | var $z = 122;
|
239 | var $LBRACE = 123;
|
240 |
|
241 | var $RBRACE = 125;
|
242 | var $NBSP = 160;
|
243 | var $PIPE = 124;
|
244 | var $TILDA = 126;
|
245 | var $AT = 64;
|
246 |
|
247 | function isWhitespace(code) {
|
248 | return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
|
249 | }
|
250 | function isDigit(code) {
|
251 | return $0 <= code && code <= $9;
|
252 | }
|
253 | function isAsciiLetter(code) {
|
254 | return code >= $a && code <= $z || code >= $A && code <= $Z;
|
255 | }
|
256 |
|
257 | var ParseLocation = (function () {
|
258 | function ParseLocation(file, offset, line, col) {
|
259 | this.file = file;
|
260 | this.offset = offset;
|
261 | this.line = line;
|
262 | this.col = col;
|
263 | }
|
264 | ParseLocation.prototype.toString = function () {
|
265 | return this.offset ? this.file.url + "@" + this.line + ":" + this.col : this.file.url;
|
266 | };
|
267 | return ParseLocation;
|
268 | }());
|
269 | var ParseSourceFile = (function () {
|
270 | function ParseSourceFile(content, url) {
|
271 | this.content = content;
|
272 | this.url = url;
|
273 | }
|
274 | return ParseSourceFile;
|
275 | }());
|
276 | var ParseSourceSpan = (function () {
|
277 | function ParseSourceSpan(start, end, details) {
|
278 | if (details === void 0) { details = null; }
|
279 | this.start = start;
|
280 | this.end = end;
|
281 | this.details = details;
|
282 | }
|
283 | ParseSourceSpan.prototype.toString = function () {
|
284 | return this.start.file.content.substring(this.start.offset, this.end.offset);
|
285 | };
|
286 | return ParseSourceSpan;
|
287 | }());
|
288 | var ParseErrorLevel;
|
289 | (function (ParseErrorLevel) {
|
290 | ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING";
|
291 | ParseErrorLevel[ParseErrorLevel["FATAL"] = 1] = "FATAL";
|
292 | })(ParseErrorLevel || (ParseErrorLevel = {}));
|
293 | var ParseError = (function () {
|
294 | function ParseError(span, msg, level) {
|
295 | if (level === void 0) { level = ParseErrorLevel.FATAL; }
|
296 | this.span = span;
|
297 | this.msg = msg;
|
298 | this.level = level;
|
299 | }
|
300 | ParseError.prototype.toString = function () {
|
301 | var source = this.span.start.file.content;
|
302 | var ctxStart = this.span.start.offset;
|
303 | var contextStr = '';
|
304 | var details = '';
|
305 | if (ctxStart) {
|
306 | if (ctxStart > source.length - 1) {
|
307 | ctxStart = source.length - 1;
|
308 | }
|
309 | var ctxEnd = ctxStart;
|
310 | var ctxLen = 0;
|
311 | var ctxLines = 0;
|
312 | while (ctxLen < 100 && ctxStart > 0) {
|
313 | ctxStart--;
|
314 | ctxLen++;
|
315 | if (source[ctxStart] == '\n') {
|
316 | if (++ctxLines == 3) {
|
317 | break;
|
318 | }
|
319 | }
|
320 | }
|
321 | ctxLen = 0;
|
322 | ctxLines = 0;
|
323 | while (ctxLen < 100 && ctxEnd < source.length - 1) {
|
324 | ctxEnd++;
|
325 | ctxLen++;
|
326 | if (source[ctxEnd] == '\n') {
|
327 | if (++ctxLines == 3) {
|
328 | break;
|
329 | }
|
330 | }
|
331 | }
|
332 | var context = source.substring(ctxStart, this.span.start.offset) + '[ERROR ->]' +
|
333 | source.substring(this.span.start.offset, ctxEnd + 1);
|
334 | contextStr = " (\"" + context + "\")";
|
335 | }
|
336 | if (this.span.details) {
|
337 | details = ", " + this.span.details;
|
338 | }
|
339 | return "" + this.msg + contextStr + ": " + this.span.start + details;
|
340 | };
|
341 | return ParseError;
|
342 | }());
|
343 |
|
344 |
|
345 |
|
346 |
|
347 |
|
348 |
|
349 |
|
350 |
|
351 |
|
352 | var CssTokenType;
|
353 | (function (CssTokenType) {
|
354 | CssTokenType[CssTokenType["EOF"] = 0] = "EOF";
|
355 | CssTokenType[CssTokenType["String"] = 1] = "String";
|
356 | CssTokenType[CssTokenType["Comment"] = 2] = "Comment";
|
357 | CssTokenType[CssTokenType["Identifier"] = 3] = "Identifier";
|
358 | CssTokenType[CssTokenType["Number"] = 4] = "Number";
|
359 | CssTokenType[CssTokenType["IdentifierOrNumber"] = 5] = "IdentifierOrNumber";
|
360 | CssTokenType[CssTokenType["AtKeyword"] = 6] = "AtKeyword";
|
361 | CssTokenType[CssTokenType["Character"] = 7] = "Character";
|
362 | CssTokenType[CssTokenType["Whitespace"] = 8] = "Whitespace";
|
363 | CssTokenType[CssTokenType["Invalid"] = 9] = "Invalid";
|
364 | })(CssTokenType || (CssTokenType = {}));
|
365 | var CssLexerMode;
|
366 | (function (CssLexerMode) {
|
367 | CssLexerMode[CssLexerMode["ALL"] = 0] = "ALL";
|
368 | CssLexerMode[CssLexerMode["ALL_TRACK_WS"] = 1] = "ALL_TRACK_WS";
|
369 | CssLexerMode[CssLexerMode["SELECTOR"] = 2] = "SELECTOR";
|
370 | CssLexerMode[CssLexerMode["PSEUDO_SELECTOR"] = 3] = "PSEUDO_SELECTOR";
|
371 | CssLexerMode[CssLexerMode["PSEUDO_SELECTOR_WITH_ARGUMENTS"] = 4] = "PSEUDO_SELECTOR_WITH_ARGUMENTS";
|
372 | CssLexerMode[CssLexerMode["ATTRIBUTE_SELECTOR"] = 5] = "ATTRIBUTE_SELECTOR";
|
373 | CssLexerMode[CssLexerMode["AT_RULE_QUERY"] = 6] = "AT_RULE_QUERY";
|
374 | CssLexerMode[CssLexerMode["MEDIA_QUERY"] = 7] = "MEDIA_QUERY";
|
375 | CssLexerMode[CssLexerMode["BLOCK"] = 8] = "BLOCK";
|
376 | CssLexerMode[CssLexerMode["KEYFRAME_BLOCK"] = 9] = "KEYFRAME_BLOCK";
|
377 | CssLexerMode[CssLexerMode["STYLE_BLOCK"] = 10] = "STYLE_BLOCK";
|
378 | CssLexerMode[CssLexerMode["STYLE_VALUE"] = 11] = "STYLE_VALUE";
|
379 | CssLexerMode[CssLexerMode["STYLE_VALUE_FUNCTION"] = 12] = "STYLE_VALUE_FUNCTION";
|
380 | CssLexerMode[CssLexerMode["STYLE_CALC_FUNCTION"] = 13] = "STYLE_CALC_FUNCTION";
|
381 | })(CssLexerMode || (CssLexerMode = {}));
|
382 | var LexedCssResult = (function () {
|
383 | function LexedCssResult(error, token) {
|
384 | this.error = error;
|
385 | this.token = token;
|
386 | }
|
387 | return LexedCssResult;
|
388 | }());
|
389 | function generateErrorMessage(input, message, errorValue, index, row, column) {
|
390 | return message + " at column " + row + ":" + column + " in expression [" +
|
391 | findProblemCode(input, errorValue, index, column) + ']';
|
392 | }
|
393 | function findProblemCode(input, errorValue, index, column) {
|
394 | var endOfProblemLine = index;
|
395 | var current = charCode(input, index);
|
396 | while (current > 0 && !isNewline(current)) {
|
397 | current = charCode(input, ++endOfProblemLine);
|
398 | }
|
399 | var choppedString = input.substring(0, endOfProblemLine);
|
400 | var pointerPadding = '';
|
401 | for (var i = 0; i < column; i++) {
|
402 | pointerPadding += ' ';
|
403 | }
|
404 | var pointerString = '';
|
405 | for (var i = 0; i < errorValue.length; i++) {
|
406 | pointerString += '^';
|
407 | }
|
408 | return choppedString + '\n' + pointerPadding + pointerString + '\n';
|
409 | }
|
410 | var CssToken = (function () {
|
411 | function CssToken(index, column, line, type, strValue) {
|
412 | this.index = index;
|
413 | this.column = column;
|
414 | this.line = line;
|
415 | this.type = type;
|
416 | this.strValue = strValue;
|
417 | this.numValue = charCode(strValue, 0);
|
418 | }
|
419 | return CssToken;
|
420 | }());
|
421 | var CssLexer = (function () {
|
422 | function CssLexer() {
|
423 | }
|
424 | CssLexer.prototype.scan = function (text, trackComments) {
|
425 | if (trackComments === void 0) { trackComments = false; }
|
426 | return new CssScanner(text, trackComments);
|
427 | };
|
428 | return CssLexer;
|
429 | }());
|
430 | var CssScannerError = (function () {
|
431 | function CssScannerError(token, message) {
|
432 | this.token = token;
|
433 | this.rawMessage = message;
|
434 | }
|
435 | CssScannerError.prototype.toString = function () { return this.message; };
|
436 | return CssScannerError;
|
437 | }());
|
438 | function _trackWhitespace(mode) {
|
439 | switch (mode) {
|
440 | case CssLexerMode.SELECTOR:
|
441 | case CssLexerMode.PSEUDO_SELECTOR:
|
442 | case CssLexerMode.ALL_TRACK_WS:
|
443 | case CssLexerMode.STYLE_VALUE:
|
444 | return true;
|
445 | default:
|
446 | return false;
|
447 | }
|
448 | }
|
449 | var CssScanner = (function () {
|
450 | function CssScanner(input, _trackComments) {
|
451 | if (_trackComments === void 0) { _trackComments = false; }
|
452 | this.input = input;
|
453 | this._trackComments = _trackComments;
|
454 | this.length = 0;
|
455 | this.index = -1;
|
456 | this.column = -1;
|
457 | this.line = 0;
|
458 |
|
459 | this._currentMode = CssLexerMode.BLOCK;
|
460 |
|
461 | this._currentError = null;
|
462 | this.length = this.input.length;
|
463 | this.peekPeek = this.peekAt(0);
|
464 | this.advance();
|
465 | }
|
466 | CssScanner.prototype.getMode = function () { return this._currentMode; };
|
467 | CssScanner.prototype.setMode = function (mode) {
|
468 | if (this._currentMode != mode) {
|
469 | if (_trackWhitespace(this._currentMode) && !_trackWhitespace(mode)) {
|
470 | this.consumeWhitespace();
|
471 | }
|
472 | this._currentMode = mode;
|
473 | }
|
474 | };
|
475 | CssScanner.prototype.advance = function () {
|
476 | if (isNewline(this.peek)) {
|
477 | this.column = 0;
|
478 | this.line++;
|
479 | }
|
480 | else {
|
481 | this.column++;
|
482 | }
|
483 | this.index++;
|
484 | this.peek = this.peekPeek;
|
485 | this.peekPeek = this.peekAt(this.index + 1);
|
486 | };
|
487 | CssScanner.prototype.peekAt = function (index) {
|
488 | return index >= this.length ? $EOF : this.input.charCodeAt(index);
|
489 | };
|
490 | CssScanner.prototype.consumeEmptyStatements = function () {
|
491 | this.consumeWhitespace();
|
492 | while (this.peek == $SEMICOLON) {
|
493 | this.advance();
|
494 | this.consumeWhitespace();
|
495 | }
|
496 | };
|
497 | CssScanner.prototype.consumeWhitespace = function () {
|
498 | while (isWhitespace(this.peek) || isNewline(this.peek)) {
|
499 | this.advance();
|
500 | if (!this._trackComments && isCommentStart(this.peek, this.peekPeek)) {
|
501 | this.advance();
|
502 | this.advance();
|
503 | while (!isCommentEnd(this.peek, this.peekPeek)) {
|
504 | if (this.peek == $EOF) {
|
505 | this.error('Unterminated comment');
|
506 | }
|
507 | this.advance();
|
508 | }
|
509 | this.advance();
|
510 | this.advance();
|
511 | }
|
512 | }
|
513 | };
|
514 | CssScanner.prototype.consume = function (type, value) {
|
515 | if (value === void 0) { value = null; }
|
516 | var mode = this._currentMode;
|
517 | this.setMode(_trackWhitespace(mode) ? CssLexerMode.ALL_TRACK_WS : CssLexerMode.ALL);
|
518 | var previousIndex = this.index;
|
519 | var previousLine = this.line;
|
520 | var previousColumn = this.column;
|
521 | var next;
|
522 | var output = this.scan();
|
523 | if (output) {
|
524 |
|
525 | if (output.error) {
|
526 | this.setMode(mode);
|
527 | return output;
|
528 | }
|
529 | next = output.token;
|
530 | }
|
531 | if (!next) {
|
532 | next = new CssToken(this.index, this.column, this.line, CssTokenType.EOF, 'end of file');
|
533 | }
|
534 | var isMatchingType = false;
|
535 | if (type == CssTokenType.IdentifierOrNumber) {
|
536 |
|
537 | isMatchingType = next.type == CssTokenType.Number || next.type == CssTokenType.Identifier;
|
538 | }
|
539 | else {
|
540 | isMatchingType = next.type == type;
|
541 | }
|
542 |
|
543 |
|
544 | this.setMode(mode);
|
545 | var error = null;
|
546 | if (!isMatchingType || (value && value != next.strValue)) {
|
547 | var errorMessage = CssTokenType[next.type] + ' does not match expected ' +
|
548 | CssTokenType[type] + ' value';
|
549 | if (value) {
|
550 | errorMessage += ' ("' + next.strValue + '" should match "' + value + '")';
|
551 | }
|
552 | error = new CssScannerError(next, generateErrorMessage(this.input, errorMessage, next.strValue, previousIndex, previousLine, previousColumn));
|
553 | }
|
554 | return new LexedCssResult(error, next);
|
555 | };
|
556 | CssScanner.prototype.scan = function () {
|
557 | var trackWS = _trackWhitespace(this._currentMode);
|
558 | if (this.index == 0 && !trackWS) {
|
559 | this.consumeWhitespace();
|
560 | }
|
561 | var token = this._scan();
|
562 | if (token == null)
|
563 | return null;
|
564 | var error = this._currentError;
|
565 | this._currentError = null;
|
566 | if (!trackWS) {
|
567 | this.consumeWhitespace();
|
568 | }
|
569 | return new LexedCssResult(error, token);
|
570 | };
|
571 |
|
572 | CssScanner.prototype._scan = function () {
|
573 | var peek = this.peek;
|
574 | var peekPeek = this.peekPeek;
|
575 | if (peek == $EOF)
|
576 | return null;
|
577 | if (isCommentStart(peek, peekPeek)) {
|
578 |
|
579 |
|
580 | var commentToken = this.scanComment();
|
581 | if (this._trackComments) {
|
582 | return commentToken;
|
583 | }
|
584 | }
|
585 | if (_trackWhitespace(this._currentMode) && (isWhitespace(peek) || isNewline(peek))) {
|
586 | return this.scanWhitespace();
|
587 | }
|
588 | peek = this.peek;
|
589 | peekPeek = this.peekPeek;
|
590 | if (peek == $EOF)
|
591 | return null;
|
592 | if (isStringStart(peek, peekPeek)) {
|
593 | return this.scanString();
|
594 | }
|
595 |
|
596 | if (this._currentMode == CssLexerMode.STYLE_VALUE_FUNCTION) {
|
597 | return this.scanCssValueFunction();
|
598 | }
|
599 | var isModifier = peek == $PLUS || peek == $MINUS;
|
600 | var digitA = isModifier ? false : isDigit(peek);
|
601 | var digitB = isDigit(peekPeek);
|
602 | if (digitA || (isModifier && (peekPeek == $PERIOD || digitB)) ||
|
603 | (peek == $PERIOD && digitB)) {
|
604 | return this.scanNumber();
|
605 | }
|
606 | if (peek == $AT) {
|
607 | return this.scanAtExpression();
|
608 | }
|
609 | if (isIdentifierStart(peek, peekPeek)) {
|
610 | return this.scanIdentifier();
|
611 | }
|
612 | if (isValidCssCharacter(peek, this._currentMode)) {
|
613 | return this.scanCharacter();
|
614 | }
|
615 | return this.error("Unexpected character [" + String.fromCharCode(peek) + "]");
|
616 | };
|
617 | CssScanner.prototype.scanComment = function () {
|
618 | if (this.assertCondition(isCommentStart(this.peek, this.peekPeek), 'Expected comment start value')) {
|
619 | return null;
|
620 | }
|
621 | var start = this.index;
|
622 | var startingColumn = this.column;
|
623 | var startingLine = this.line;
|
624 | this.advance();
|
625 | this.advance();
|
626 | while (!isCommentEnd(this.peek, this.peekPeek)) {
|
627 | if (this.peek == $EOF) {
|
628 | this.error('Unterminated comment');
|
629 | }
|
630 | this.advance();
|
631 | }
|
632 | this.advance();
|
633 | this.advance();
|
634 | var str = this.input.substring(start, this.index);
|
635 | return new CssToken(start, startingColumn, startingLine, CssTokenType.Comment, str);
|
636 | };
|
637 | CssScanner.prototype.scanWhitespace = function () {
|
638 | var start = this.index;
|
639 | var startingColumn = this.column;
|
640 | var startingLine = this.line;
|
641 | while (isWhitespace(this.peek) && this.peek != $EOF) {
|
642 | this.advance();
|
643 | }
|
644 | var str = this.input.substring(start, this.index);
|
645 | return new CssToken(start, startingColumn, startingLine, CssTokenType.Whitespace, str);
|
646 | };
|
647 | CssScanner.prototype.scanString = function () {
|
648 | if (this.assertCondition(isStringStart(this.peek, this.peekPeek), 'Unexpected non-string starting value')) {
|
649 | return null;
|
650 | }
|
651 | var target = this.peek;
|
652 | var start = this.index;
|
653 | var startingColumn = this.column;
|
654 | var startingLine = this.line;
|
655 | var previous = target;
|
656 | this.advance();
|
657 | while (!isCharMatch(target, previous, this.peek)) {
|
658 | if (this.peek == $EOF || isNewline(this.peek)) {
|
659 | this.error('Unterminated quote');
|
660 | }
|
661 | previous = this.peek;
|
662 | this.advance();
|
663 | }
|
664 | if (this.assertCondition(this.peek == target, 'Unterminated quote')) {
|
665 | return null;
|
666 | }
|
667 | this.advance();
|
668 | var str = this.input.substring(start, this.index);
|
669 | return new CssToken(start, startingColumn, startingLine, CssTokenType.String, str);
|
670 | };
|
671 | CssScanner.prototype.scanNumber = function () {
|
672 | var start = this.index;
|
673 | var startingColumn = this.column;
|
674 | if (this.peek == $PLUS || this.peek == $MINUS) {
|
675 | this.advance();
|
676 | }
|
677 | var periodUsed = false;
|
678 | while (isDigit(this.peek) || this.peek == $PERIOD) {
|
679 | if (this.peek == $PERIOD) {
|
680 | if (periodUsed) {
|
681 | this.error('Unexpected use of a second period value');
|
682 | }
|
683 | periodUsed = true;
|
684 | }
|
685 | this.advance();
|
686 | }
|
687 | var strValue = this.input.substring(start, this.index);
|
688 | return new CssToken(start, startingColumn, this.line, CssTokenType.Number, strValue);
|
689 | };
|
690 | CssScanner.prototype.scanIdentifier = function () {
|
691 | if (this.assertCondition(isIdentifierStart(this.peek, this.peekPeek), 'Expected identifier starting value')) {
|
692 | return null;
|
693 | }
|
694 | var start = this.index;
|
695 | var startingColumn = this.column;
|
696 | while (isIdentifierPart(this.peek)) {
|
697 | this.advance();
|
698 | }
|
699 | var strValue = this.input.substring(start, this.index);
|
700 | return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
|
701 | };
|
702 | CssScanner.prototype.scanCssValueFunction = function () {
|
703 | var start = this.index;
|
704 | var startingColumn = this.column;
|
705 | var parenBalance = 1;
|
706 | while (this.peek != $EOF && parenBalance > 0) {
|
707 | this.advance();
|
708 | if (this.peek == $LPAREN) {
|
709 | parenBalance++;
|
710 | }
|
711 | else if (this.peek == $RPAREN) {
|
712 | parenBalance--;
|
713 | }
|
714 | }
|
715 | var strValue = this.input.substring(start, this.index);
|
716 | return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
|
717 | };
|
718 | CssScanner.prototype.scanCharacter = function () {
|
719 | var start = this.index;
|
720 | var startingColumn = this.column;
|
721 | if (this.assertCondition(isValidCssCharacter(this.peek, this._currentMode), charStr(this.peek) + ' is not a valid CSS character')) {
|
722 | return null;
|
723 | }
|
724 | var c = this.input.substring(start, start + 1);
|
725 | this.advance();
|
726 | return new CssToken(start, startingColumn, this.line, CssTokenType.Character, c);
|
727 | };
|
728 | CssScanner.prototype.scanAtExpression = function () {
|
729 | if (this.assertCondition(this.peek == $AT, 'Expected @ value')) {
|
730 | return null;
|
731 | }
|
732 | var start = this.index;
|
733 | var startingColumn = this.column;
|
734 | this.advance();
|
735 | if (isIdentifierStart(this.peek, this.peekPeek)) {
|
736 | var ident = this.scanIdentifier();
|
737 | var strValue = '@' + ident.strValue;
|
738 | return new CssToken(start, startingColumn, this.line, CssTokenType.AtKeyword, strValue);
|
739 | }
|
740 | else {
|
741 | return this.scanCharacter();
|
742 | }
|
743 | };
|
744 | CssScanner.prototype.assertCondition = function (status, errorMessage) {
|
745 | if (!status) {
|
746 | this.error(errorMessage);
|
747 | return true;
|
748 | }
|
749 | return false;
|
750 | };
|
751 | CssScanner.prototype.error = function (message, errorTokenValue, doNotAdvance) {
|
752 | if (errorTokenValue === void 0) { errorTokenValue = null; }
|
753 | if (doNotAdvance === void 0) { doNotAdvance = false; }
|
754 | var index = this.index;
|
755 | var column = this.column;
|
756 | var line = this.line;
|
757 | errorTokenValue =
|
758 | errorTokenValue ? errorTokenValue : String.fromCharCode(this.peek);
|
759 | var invalidToken = new CssToken(index, column, line, CssTokenType.Invalid, errorTokenValue);
|
760 | var errorMessage = generateErrorMessage(this.input, message, errorTokenValue, index, line, column);
|
761 | if (!doNotAdvance) {
|
762 | this.advance();
|
763 | }
|
764 | this._currentError = new CssScannerError(invalidToken, errorMessage);
|
765 | return invalidToken;
|
766 | };
|
767 | return CssScanner;
|
768 | }());
|
769 | function isCharMatch(target, previous, code) {
|
770 | return code == target && previous != $BACKSLASH;
|
771 | }
|
772 | function isCommentStart(code, next) {
|
773 | return code == $SLASH && next == $STAR;
|
774 | }
|
775 | function isCommentEnd(code, next) {
|
776 | return code == $STAR && next == $SLASH;
|
777 | }
|
778 | function isStringStart(code, next) {
|
779 | var target = code;
|
780 | if (target == $BACKSLASH) {
|
781 | target = next;
|
782 | }
|
783 | return target == $DQ || target == $SQ;
|
784 | }
|
785 | function isIdentifierStart(code, next) {
|
786 | var target = code;
|
787 | if (target == $MINUS) {
|
788 | target = next;
|
789 | }
|
790 | return isAsciiLetter(target) || target == $BACKSLASH || target == $MINUS ||
|
791 | target == $_;
|
792 | }
|
793 | function isIdentifierPart(target) {
|
794 | return isAsciiLetter(target) || target == $BACKSLASH || target == $MINUS ||
|
795 | target == $_ || isDigit(target);
|
796 | }
|
797 | function isValidPseudoSelectorCharacter(code) {
|
798 | switch (code) {
|
799 | case $LPAREN:
|
800 | case $RPAREN:
|
801 | return true;
|
802 | default:
|
803 | return false;
|
804 | }
|
805 | }
|
806 | function isValidKeyframeBlockCharacter(code) {
|
807 | return code == $PERCENT;
|
808 | }
|
809 | function isValidAttributeSelectorCharacter(code) {
|
810 |
|
811 | switch (code) {
|
812 | case $$:
|
813 | case $PIPE:
|
814 | case $CARET:
|
815 | case $TILDA:
|
816 | case $STAR:
|
817 | case $EQ:
|
818 | return true;
|
819 | default:
|
820 | return false;
|
821 | }
|
822 | }
|
823 | function isValidSelectorCharacter(code) {
|
824 |
|
825 |
|
826 |
|
827 |
|
828 | switch (code) {
|
829 | case $HASH:
|
830 | case $PERIOD:
|
831 | case $TILDA:
|
832 | case $STAR:
|
833 | case $PLUS:
|
834 | case $GT:
|
835 | case $COLON:
|
836 | case $PIPE:
|
837 | case $COMMA:
|
838 | case $LBRACKET:
|
839 | case $RBRACKET:
|
840 | return true;
|
841 | default:
|
842 | return false;
|
843 | }
|
844 | }
|
845 | function isValidStyleBlockCharacter(code) {
|
846 |
|
847 |
|
848 | switch (code) {
|
849 | case $HASH:
|
850 | case $SEMICOLON:
|
851 | case $COLON:
|
852 | case $PERCENT:
|
853 | case $SLASH:
|
854 | case $BACKSLASH:
|
855 | case $BANG:
|
856 | case $PERIOD:
|
857 | case $LPAREN:
|
858 | case $RPAREN:
|
859 | return true;
|
860 | default:
|
861 | return false;
|
862 | }
|
863 | }
|
864 | function isValidMediaQueryRuleCharacter(code) {
|
865 |
|
866 | switch (code) {
|
867 | case $LPAREN:
|
868 | case $RPAREN:
|
869 | case $COLON:
|
870 | case $PERCENT:
|
871 | case $PERIOD:
|
872 | return true;
|
873 | default:
|
874 | return false;
|
875 | }
|
876 | }
|
877 | function isValidAtRuleCharacter(code) {
|
878 |
|
879 | switch (code) {
|
880 | case $LPAREN:
|
881 | case $RPAREN:
|
882 | case $COLON:
|
883 | case $PERCENT:
|
884 | case $PERIOD:
|
885 | case $SLASH:
|
886 | case $BACKSLASH:
|
887 | case $HASH:
|
888 | case $EQ:
|
889 | case $QUESTION:
|
890 | case $AMPERSAND:
|
891 | case $STAR:
|
892 | case $COMMA:
|
893 | case $MINUS:
|
894 | case $PLUS:
|
895 | return true;
|
896 | default:
|
897 | return false;
|
898 | }
|
899 | }
|
900 | function isValidStyleFunctionCharacter(code) {
|
901 | switch (code) {
|
902 | case $PERIOD:
|
903 | case $MINUS:
|
904 | case $PLUS:
|
905 | case $STAR:
|
906 | case $SLASH:
|
907 | case $LPAREN:
|
908 | case $RPAREN:
|
909 | case $COMMA:
|
910 | return true;
|
911 | default:
|
912 | return false;
|
913 | }
|
914 | }
|
915 | function isValidBlockCharacter(code) {
|
916 |
|
917 |
|
918 | return code == $AT;
|
919 | }
|
920 | function isValidCssCharacter(code, mode) {
|
921 | switch (mode) {
|
922 | case CssLexerMode.ALL:
|
923 | case CssLexerMode.ALL_TRACK_WS:
|
924 | return true;
|
925 | case CssLexerMode.SELECTOR:
|
926 | return isValidSelectorCharacter(code);
|
927 | case CssLexerMode.PSEUDO_SELECTOR_WITH_ARGUMENTS:
|
928 | return isValidPseudoSelectorCharacter(code);
|
929 | case CssLexerMode.ATTRIBUTE_SELECTOR:
|
930 | return isValidAttributeSelectorCharacter(code);
|
931 | case CssLexerMode.MEDIA_QUERY:
|
932 | return isValidMediaQueryRuleCharacter(code);
|
933 | case CssLexerMode.AT_RULE_QUERY:
|
934 | return isValidAtRuleCharacter(code);
|
935 | case CssLexerMode.KEYFRAME_BLOCK:
|
936 | return isValidKeyframeBlockCharacter(code);
|
937 | case CssLexerMode.STYLE_BLOCK:
|
938 | case CssLexerMode.STYLE_VALUE:
|
939 | return isValidStyleBlockCharacter(code);
|
940 | case CssLexerMode.STYLE_CALC_FUNCTION:
|
941 | return isValidStyleFunctionCharacter(code);
|
942 | case CssLexerMode.BLOCK:
|
943 | return isValidBlockCharacter(code);
|
944 | default:
|
945 | return false;
|
946 | }
|
947 | }
|
948 | function charCode(input, index) {
|
949 | return index >= input.length ? $EOF : input.charCodeAt(index);
|
950 | }
|
951 | function charStr(code) {
|
952 | return String.fromCharCode(code);
|
953 | }
|
954 | function isNewline(code) {
|
955 | switch (code) {
|
956 | case $FF:
|
957 | case $CR:
|
958 | case $LF:
|
959 | case $VTAB:
|
960 | return true;
|
961 | default:
|
962 | return false;
|
963 | }
|
964 | }
|
965 |
|
966 |
|
967 |
|
968 |
|
969 |
|
970 |
|
971 |
|
972 |
|
973 |
|
974 | var __extends$4 = (undefined && undefined.__extends) || (function () {
|
975 | var extendStatics = Object.setPrototypeOf ||
|
976 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
977 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
978 | return function (d, b) {
|
979 | extendStatics(d, b);
|
980 | function __() { this.constructor = d; }
|
981 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
982 | };
|
983 | })();
|
984 | var BlockType;
|
985 | (function (BlockType) {
|
986 | BlockType[BlockType["Import"] = 0] = "Import";
|
987 | BlockType[BlockType["Charset"] = 1] = "Charset";
|
988 | BlockType[BlockType["Namespace"] = 2] = "Namespace";
|
989 | BlockType[BlockType["Supports"] = 3] = "Supports";
|
990 | BlockType[BlockType["Keyframes"] = 4] = "Keyframes";
|
991 | BlockType[BlockType["MediaQuery"] = 5] = "MediaQuery";
|
992 | BlockType[BlockType["Selector"] = 6] = "Selector";
|
993 | BlockType[BlockType["FontFace"] = 7] = "FontFace";
|
994 | BlockType[BlockType["Page"] = 8] = "Page";
|
995 | BlockType[BlockType["Document"] = 9] = "Document";
|
996 | BlockType[BlockType["Viewport"] = 10] = "Viewport";
|
997 | BlockType[BlockType["Unsupported"] = 11] = "Unsupported";
|
998 | })(BlockType || (BlockType = {}));
|
999 | var CssAst = (function () {
|
1000 | function CssAst(location) {
|
1001 | this.location = location;
|
1002 | }
|
1003 | Object.defineProperty(CssAst.prototype, "start", {
|
1004 | get: function () { return this.location.start; },
|
1005 | enumerable: true,
|
1006 | configurable: true
|
1007 | });
|
1008 | Object.defineProperty(CssAst.prototype, "end", {
|
1009 | get: function () { return this.location.end; },
|
1010 | enumerable: true,
|
1011 | configurable: true
|
1012 | });
|
1013 | return CssAst;
|
1014 | }());
|
1015 | var CssStyleValueAst = (function (_super) {
|
1016 | __extends$4(CssStyleValueAst, _super);
|
1017 | function CssStyleValueAst(location, tokens, strValue) {
|
1018 | var _this = _super.call(this, location) || this;
|
1019 | _this.tokens = tokens;
|
1020 | _this.strValue = strValue;
|
1021 | return _this;
|
1022 | }
|
1023 | CssStyleValueAst.prototype.visit = function (visitor, context) { return visitor.visitCssValue(this); };
|
1024 | return CssStyleValueAst;
|
1025 | }(CssAst));
|
1026 | var CssRuleAst = (function (_super) {
|
1027 | __extends$4(CssRuleAst, _super);
|
1028 | function CssRuleAst(location) {
|
1029 | return _super.call(this, location) || this;
|
1030 | }
|
1031 | return CssRuleAst;
|
1032 | }(CssAst));
|
1033 | var CssBlockRuleAst = (function (_super) {
|
1034 | __extends$4(CssBlockRuleAst, _super);
|
1035 | function CssBlockRuleAst(location, type, block, name) {
|
1036 | if (name === void 0) { name = null; }
|
1037 | var _this = _super.call(this, location) || this;
|
1038 | _this.location = location;
|
1039 | _this.type = type;
|
1040 | _this.block = block;
|
1041 | _this.name = name;
|
1042 | return _this;
|
1043 | }
|
1044 | CssBlockRuleAst.prototype.visit = function (visitor, context) {
|
1045 | return visitor.visitCssBlock(this.block, context);
|
1046 | };
|
1047 | return CssBlockRuleAst;
|
1048 | }(CssRuleAst));
|
1049 | var CssKeyframeRuleAst = (function (_super) {
|
1050 | __extends$4(CssKeyframeRuleAst, _super);
|
1051 | function CssKeyframeRuleAst(location, name, block) {
|
1052 | return _super.call(this, location, BlockType.Keyframes, block, name) || this;
|
1053 | }
|
1054 | CssKeyframeRuleAst.prototype.visit = function (visitor, context) {
|
1055 | return visitor.visitCssKeyframeRule(this, context);
|
1056 | };
|
1057 | return CssKeyframeRuleAst;
|
1058 | }(CssBlockRuleAst));
|
1059 | var CssKeyframeDefinitionAst = (function (_super) {
|
1060 | __extends$4(CssKeyframeDefinitionAst, _super);
|
1061 | function CssKeyframeDefinitionAst(location, steps, block) {
|
1062 | var _this = _super.call(this, location, BlockType.Keyframes, block, mergeTokens(steps, ',')) || this;
|
1063 | _this.steps = steps;
|
1064 | return _this;
|
1065 | }
|
1066 | CssKeyframeDefinitionAst.prototype.visit = function (visitor, context) {
|
1067 | return visitor.visitCssKeyframeDefinition(this, context);
|
1068 | };
|
1069 | return CssKeyframeDefinitionAst;
|
1070 | }(CssBlockRuleAst));
|
1071 | var CssBlockDefinitionRuleAst = (function (_super) {
|
1072 | __extends$4(CssBlockDefinitionRuleAst, _super);
|
1073 | function CssBlockDefinitionRuleAst(location, strValue, type, query, block) {
|
1074 | var _this = _super.call(this, location, type, block) || this;
|
1075 | _this.strValue = strValue;
|
1076 | _this.query = query;
|
1077 | var firstCssToken = query.tokens[0];
|
1078 | _this.name = new CssToken(firstCssToken.index, firstCssToken.column, firstCssToken.line, CssTokenType.Identifier, _this.strValue);
|
1079 | return _this;
|
1080 | }
|
1081 | CssBlockDefinitionRuleAst.prototype.visit = function (visitor, context) {
|
1082 | return visitor.visitCssBlock(this.block, context);
|
1083 | };
|
1084 | return CssBlockDefinitionRuleAst;
|
1085 | }(CssBlockRuleAst));
|
1086 | var CssMediaQueryRuleAst = (function (_super) {
|
1087 | __extends$4(CssMediaQueryRuleAst, _super);
|
1088 | function CssMediaQueryRuleAst(location, strValue, query, block) {
|
1089 | return _super.call(this, location, strValue, BlockType.MediaQuery, query, block) || this;
|
1090 | }
|
1091 | CssMediaQueryRuleAst.prototype.visit = function (visitor, context) {
|
1092 | return visitor.visitCssMediaQueryRule(this, context);
|
1093 | };
|
1094 | return CssMediaQueryRuleAst;
|
1095 | }(CssBlockDefinitionRuleAst));
|
1096 | var CssAtRulePredicateAst = (function (_super) {
|
1097 | __extends$4(CssAtRulePredicateAst, _super);
|
1098 | function CssAtRulePredicateAst(location, strValue, tokens) {
|
1099 | var _this = _super.call(this, location) || this;
|
1100 | _this.strValue = strValue;
|
1101 | _this.tokens = tokens;
|
1102 | return _this;
|
1103 | }
|
1104 | CssAtRulePredicateAst.prototype.visit = function (visitor, context) {
|
1105 | return visitor.visitCssAtRulePredicate(this, context);
|
1106 | };
|
1107 | return CssAtRulePredicateAst;
|
1108 | }(CssAst));
|
1109 | var CssInlineRuleAst = (function (_super) {
|
1110 | __extends$4(CssInlineRuleAst, _super);
|
1111 | function CssInlineRuleAst(location, type, value) {
|
1112 | var _this = _super.call(this, location) || this;
|
1113 | _this.type = type;
|
1114 | _this.value = value;
|
1115 | return _this;
|
1116 | }
|
1117 | CssInlineRuleAst.prototype.visit = function (visitor, context) {
|
1118 | return visitor.visitCssInlineRule(this, context);
|
1119 | };
|
1120 | return CssInlineRuleAst;
|
1121 | }(CssRuleAst));
|
1122 | var CssSelectorRuleAst = (function (_super) {
|
1123 | __extends$4(CssSelectorRuleAst, _super);
|
1124 | function CssSelectorRuleAst(location, selectors, block) {
|
1125 | var _this = _super.call(this, location, BlockType.Selector, block) || this;
|
1126 | _this.selectors = selectors;
|
1127 | _this.strValue = selectors.map(function (selector) { return selector.strValue; }).join(',');
|
1128 | return _this;
|
1129 | }
|
1130 | CssSelectorRuleAst.prototype.visit = function (visitor, context) {
|
1131 | return visitor.visitCssSelectorRule(this, context);
|
1132 | };
|
1133 | return CssSelectorRuleAst;
|
1134 | }(CssBlockRuleAst));
|
1135 | var CssDefinitionAst = (function (_super) {
|
1136 | __extends$4(CssDefinitionAst, _super);
|
1137 | function CssDefinitionAst(location, property, value) {
|
1138 | var _this = _super.call(this, location) || this;
|
1139 | _this.property = property;
|
1140 | _this.value = value;
|
1141 | return _this;
|
1142 | }
|
1143 | CssDefinitionAst.prototype.visit = function (visitor, context) {
|
1144 | return visitor.visitCssDefinition(this, context);
|
1145 | };
|
1146 | return CssDefinitionAst;
|
1147 | }(CssAst));
|
1148 | var CssSelectorPartAst = (function (_super) {
|
1149 | __extends$4(CssSelectorPartAst, _super);
|
1150 | function CssSelectorPartAst(location) {
|
1151 | return _super.call(this, location) || this;
|
1152 | }
|
1153 | return CssSelectorPartAst;
|
1154 | }(CssAst));
|
1155 | var CssSelectorAst = (function (_super) {
|
1156 | __extends$4(CssSelectorAst, _super);
|
1157 | function CssSelectorAst(location, selectorParts) {
|
1158 | var _this = _super.call(this, location) || this;
|
1159 | _this.selectorParts = selectorParts;
|
1160 | _this.strValue = selectorParts.map(function (part) { return part.strValue; }).join('');
|
1161 | return _this;
|
1162 | }
|
1163 | CssSelectorAst.prototype.visit = function (visitor, context) {
|
1164 | return visitor.visitCssSelector(this, context);
|
1165 | };
|
1166 | return CssSelectorAst;
|
1167 | }(CssSelectorPartAst));
|
1168 | var CssSimpleSelectorAst = (function (_super) {
|
1169 | __extends$4(CssSimpleSelectorAst, _super);
|
1170 | function CssSimpleSelectorAst(location, tokens, strValue, pseudoSelectors, operator) {
|
1171 | var _this = _super.call(this, location) || this;
|
1172 | _this.tokens = tokens;
|
1173 | _this.strValue = strValue;
|
1174 | _this.pseudoSelectors = pseudoSelectors;
|
1175 | _this.operator = operator;
|
1176 | return _this;
|
1177 | }
|
1178 | CssSimpleSelectorAst.prototype.visit = function (visitor, context) {
|
1179 | return visitor.visitCssSimpleSelector(this, context);
|
1180 | };
|
1181 | return CssSimpleSelectorAst;
|
1182 | }(CssSelectorPartAst));
|
1183 | var CssPseudoSelectorAst = (function (_super) {
|
1184 | __extends$4(CssPseudoSelectorAst, _super);
|
1185 | function CssPseudoSelectorAst(location, strValue, name, tokens, innerSelectors) {
|
1186 | var _this = _super.call(this, location) || this;
|
1187 | _this.strValue = strValue;
|
1188 | _this.name = name;
|
1189 | _this.tokens = tokens;
|
1190 | _this.innerSelectors = innerSelectors;
|
1191 | return _this;
|
1192 | }
|
1193 | CssPseudoSelectorAst.prototype.visit = function (visitor, context) {
|
1194 | return visitor.visitCssPseudoSelector(this, context);
|
1195 | };
|
1196 | return CssPseudoSelectorAst;
|
1197 | }(CssSelectorPartAst));
|
1198 | var CssBlockAst = (function (_super) {
|
1199 | __extends$4(CssBlockAst, _super);
|
1200 | function CssBlockAst(location, entries) {
|
1201 | var _this = _super.call(this, location) || this;
|
1202 | _this.entries = entries;
|
1203 | return _this;
|
1204 | }
|
1205 | CssBlockAst.prototype.visit = function (visitor, context) { return visitor.visitCssBlock(this, context); };
|
1206 | return CssBlockAst;
|
1207 | }(CssAst));
|
1208 |
|
1209 |
|
1210 |
|
1211 |
|
1212 | var CssStylesBlockAst = (function (_super) {
|
1213 | __extends$4(CssStylesBlockAst, _super);
|
1214 | function CssStylesBlockAst(location, definitions) {
|
1215 | var _this = _super.call(this, location, definitions) || this;
|
1216 | _this.definitions = definitions;
|
1217 | return _this;
|
1218 | }
|
1219 | CssStylesBlockAst.prototype.visit = function (visitor, context) {
|
1220 | return visitor.visitCssStylesBlock(this, context);
|
1221 | };
|
1222 | return CssStylesBlockAst;
|
1223 | }(CssBlockAst));
|
1224 | var CssStyleSheetAst = (function (_super) {
|
1225 | __extends$4(CssStyleSheetAst, _super);
|
1226 | function CssStyleSheetAst(location, rules) {
|
1227 | var _this = _super.call(this, location) || this;
|
1228 | _this.rules = rules;
|
1229 | return _this;
|
1230 | }
|
1231 | CssStyleSheetAst.prototype.visit = function (visitor, context) {
|
1232 | return visitor.visitCssStyleSheet(this, context);
|
1233 | };
|
1234 | return CssStyleSheetAst;
|
1235 | }(CssAst));
|
1236 | var CssUnknownRuleAst = (function (_super) {
|
1237 | __extends$4(CssUnknownRuleAst, _super);
|
1238 | function CssUnknownRuleAst(location, ruleName, tokens) {
|
1239 | var _this = _super.call(this, location) || this;
|
1240 | _this.ruleName = ruleName;
|
1241 | _this.tokens = tokens;
|
1242 | return _this;
|
1243 | }
|
1244 | CssUnknownRuleAst.prototype.visit = function (visitor, context) {
|
1245 | return visitor.visitCssUnknownRule(this, context);
|
1246 | };
|
1247 | return CssUnknownRuleAst;
|
1248 | }(CssRuleAst));
|
1249 | var CssUnknownTokenListAst = (function (_super) {
|
1250 | __extends$4(CssUnknownTokenListAst, _super);
|
1251 | function CssUnknownTokenListAst(location, name, tokens) {
|
1252 | var _this = _super.call(this, location) || this;
|
1253 | _this.name = name;
|
1254 | _this.tokens = tokens;
|
1255 | return _this;
|
1256 | }
|
1257 | CssUnknownTokenListAst.prototype.visit = function (visitor, context) {
|
1258 | return visitor.visitCssUnknownTokenList(this, context);
|
1259 | };
|
1260 | return CssUnknownTokenListAst;
|
1261 | }(CssRuleAst));
|
1262 | function mergeTokens(tokens, separator) {
|
1263 | if (separator === void 0) { separator = ''; }
|
1264 | var mainToken = tokens[0];
|
1265 | var str = mainToken.strValue;
|
1266 | for (var i = 1; i < tokens.length; i++) {
|
1267 | str += separator + tokens[i].strValue;
|
1268 | }
|
1269 | return new CssToken(mainToken.index, mainToken.column, mainToken.line, mainToken.type, str);
|
1270 | }
|
1271 |
|
1272 |
|
1273 | var __extends$3 = (undefined && undefined.__extends) || (function () {
|
1274 | var extendStatics = Object.setPrototypeOf ||
|
1275 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
1276 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
1277 | return function (d, b) {
|
1278 | extendStatics(d, b);
|
1279 | function __() { this.constructor = d; }
|
1280 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
1281 | };
|
1282 | })();
|
1283 |
|
1284 |
|
1285 |
|
1286 |
|
1287 |
|
1288 |
|
1289 |
|
1290 | var SPACE_OPERATOR = ' ';
|
1291 | var SLASH_CHARACTER = '/';
|
1292 | var GT_CHARACTER = '>';
|
1293 | var TRIPLE_GT_OPERATOR_STR = '>>>';
|
1294 | var DEEP_OPERATOR_STR = '/deep/';
|
1295 | var EOF_DELIM_FLAG = 1;
|
1296 | var RBRACE_DELIM_FLAG = 2;
|
1297 | var LBRACE_DELIM_FLAG = 4;
|
1298 | var COMMA_DELIM_FLAG = 8;
|
1299 | var COLON_DELIM_FLAG = 16;
|
1300 | var SEMICOLON_DELIM_FLAG = 32;
|
1301 | var NEWLINE_DELIM_FLAG = 64;
|
1302 | var RPAREN_DELIM_FLAG = 128;
|
1303 | var LPAREN_DELIM_FLAG = 256;
|
1304 | var SPACE_DELIM_FLAG = 512;
|
1305 | function _pseudoSelectorSupportsInnerSelectors(name) {
|
1306 | return ['not', 'host', 'host-context'].indexOf(name) >= 0;
|
1307 | }
|
1308 | function isSelectorOperatorCharacter(code) {
|
1309 | switch (code) {
|
1310 | case $SLASH:
|
1311 | case $TILDA:
|
1312 | case $PLUS:
|
1313 | case $GT:
|
1314 | return true;
|
1315 | default:
|
1316 | return isWhitespace(code);
|
1317 | }
|
1318 | }
|
1319 | function getDelimFromCharacter(code) {
|
1320 | switch (code) {
|
1321 | case $EOF:
|
1322 | return EOF_DELIM_FLAG;
|
1323 | case $COMMA:
|
1324 | return COMMA_DELIM_FLAG;
|
1325 | case $COLON:
|
1326 | return COLON_DELIM_FLAG;
|
1327 | case $SEMICOLON:
|
1328 | return SEMICOLON_DELIM_FLAG;
|
1329 | case $RBRACE:
|
1330 | return RBRACE_DELIM_FLAG;
|
1331 | case $LBRACE:
|
1332 | return LBRACE_DELIM_FLAG;
|
1333 | case $RPAREN:
|
1334 | return RPAREN_DELIM_FLAG;
|
1335 | case $SPACE:
|
1336 | case $TAB:
|
1337 | return SPACE_DELIM_FLAG;
|
1338 | default:
|
1339 | return isNewline(code) ? NEWLINE_DELIM_FLAG : 0;
|
1340 | }
|
1341 | }
|
1342 | function characterContainsDelimiter(code, delimiters) {
|
1343 | return (getDelimFromCharacter(code) & delimiters) > 0;
|
1344 | }
|
1345 | var ParsedCssResult = (function () {
|
1346 | function ParsedCssResult(errors, ast) {
|
1347 | this.errors = errors;
|
1348 | this.ast = ast;
|
1349 | }
|
1350 | return ParsedCssResult;
|
1351 | }());
|
1352 | var CssParser = (function () {
|
1353 | function CssParser() {
|
1354 | this._errors = [];
|
1355 | }
|
1356 | |
1357 |
|
1358 |
|
1359 |
|
1360 | CssParser.prototype.parse = function (css, url) {
|
1361 | var lexer = new CssLexer();
|
1362 | this._file = new ParseSourceFile(css, url);
|
1363 | this._scanner = lexer.scan(css, false);
|
1364 | var ast = this._parseStyleSheet(EOF_DELIM_FLAG);
|
1365 | var errors = this._errors;
|
1366 | this._errors = [];
|
1367 | var result = new ParsedCssResult(errors, ast);
|
1368 | this._file = null;
|
1369 | this._scanner = null;
|
1370 | return result;
|
1371 | };
|
1372 |
|
1373 | CssParser.prototype._parseStyleSheet = function (delimiters) {
|
1374 | var results = [];
|
1375 | this._scanner.consumeEmptyStatements();
|
1376 | while (this._scanner.peek != $EOF) {
|
1377 | this._scanner.setMode(CssLexerMode.BLOCK);
|
1378 | results.push(this._parseRule(delimiters));
|
1379 | }
|
1380 | var span = null;
|
1381 | if (results.length > 0) {
|
1382 | var firstRule = results[0];
|
1383 |
|
1384 |
|
1385 | span = this._generateSourceSpan(firstRule, this._lastToken);
|
1386 | }
|
1387 | return new CssStyleSheetAst(span, results);
|
1388 | };
|
1389 |
|
1390 | CssParser.prototype._getSourceContent = function () { return this._scanner ? this._scanner.input : ''; };
|
1391 |
|
1392 | CssParser.prototype._extractSourceContent = function (start, end) {
|
1393 | return this._getSourceContent().substring(start, end + 1);
|
1394 | };
|
1395 |
|
1396 | CssParser.prototype._generateSourceSpan = function (start, end) {
|
1397 | if (end === void 0) { end = null; }
|
1398 | var startLoc;
|
1399 | if (start instanceof CssAst) {
|
1400 | startLoc = start.location.start;
|
1401 | }
|
1402 | else {
|
1403 | var token = start;
|
1404 | if (!token) {
|
1405 |
|
1406 |
|
1407 | token = this._lastToken;
|
1408 | }
|
1409 | startLoc = new ParseLocation(this._file, token.index, token.line, token.column);
|
1410 | }
|
1411 | if (!end) {
|
1412 | end = this._lastToken;
|
1413 | }
|
1414 | var endLine;
|
1415 | var endColumn;
|
1416 | var endIndex;
|
1417 | if (end instanceof CssAst) {
|
1418 | endLine = end.location.end.line;
|
1419 | endColumn = end.location.end.col;
|
1420 | endIndex = end.location.end.offset;
|
1421 | }
|
1422 | else if (end instanceof CssToken) {
|
1423 | endLine = end.line;
|
1424 | endColumn = end.column;
|
1425 | endIndex = end.index;
|
1426 | }
|
1427 | var endLoc = new ParseLocation(this._file, endIndex, endLine, endColumn);
|
1428 | return new ParseSourceSpan(startLoc, endLoc);
|
1429 | };
|
1430 |
|
1431 | CssParser.prototype._resolveBlockType = function (token) {
|
1432 | switch (token.strValue) {
|
1433 | case '@-o-keyframes':
|
1434 | case '@-moz-keyframes':
|
1435 | case '@-webkit-keyframes':
|
1436 | case '@keyframes':
|
1437 | return BlockType.Keyframes;
|
1438 | case '@charset':
|
1439 | return BlockType.Charset;
|
1440 | case '@import':
|
1441 | return BlockType.Import;
|
1442 | case '@namespace':
|
1443 | return BlockType.Namespace;
|
1444 | case '@page':
|
1445 | return BlockType.Page;
|
1446 | case '@document':
|
1447 | return BlockType.Document;
|
1448 | case '@media':
|
1449 | return BlockType.MediaQuery;
|
1450 | case '@font-face':
|
1451 | return BlockType.FontFace;
|
1452 | case '@viewport':
|
1453 | return BlockType.Viewport;
|
1454 | case '@supports':
|
1455 | return BlockType.Supports;
|
1456 | default:
|
1457 | return BlockType.Unsupported;
|
1458 | }
|
1459 | };
|
1460 |
|
1461 | CssParser.prototype._parseRule = function (delimiters) {
|
1462 | if (this._scanner.peek == $AT) {
|
1463 | return this._parseAtRule(delimiters);
|
1464 | }
|
1465 | return this._parseSelectorRule(delimiters);
|
1466 | };
|
1467 |
|
1468 | CssParser.prototype._parseAtRule = function (delimiters) {
|
1469 | var start = this._getScannerIndex();
|
1470 | this._scanner.setMode(CssLexerMode.BLOCK);
|
1471 | var token = this._scan();
|
1472 | var startToken = token;
|
1473 | this._assertCondition(token.type == CssTokenType.AtKeyword, "The CSS Rule " + token.strValue + " is not a valid [@] rule.", token);
|
1474 | var block;
|
1475 | var type = this._resolveBlockType(token);
|
1476 | var span;
|
1477 | var tokens;
|
1478 | var endToken;
|
1479 | var end;
|
1480 | var strValue;
|
1481 | var query;
|
1482 | switch (type) {
|
1483 | case BlockType.Charset:
|
1484 | case BlockType.Namespace:
|
1485 | case BlockType.Import:
|
1486 | var value = this._parseValue(delimiters);
|
1487 | this._scanner.setMode(CssLexerMode.BLOCK);
|
1488 | this._scanner.consumeEmptyStatements();
|
1489 | span = this._generateSourceSpan(startToken, value);
|
1490 | return new CssInlineRuleAst(span, type, value);
|
1491 | case BlockType.Viewport:
|
1492 | case BlockType.FontFace:
|
1493 | block = this._parseStyleBlock(delimiters);
|
1494 | span = this._generateSourceSpan(startToken, block);
|
1495 | return new CssBlockRuleAst(span, type, block);
|
1496 | case BlockType.Keyframes:
|
1497 | tokens = this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG);
|
1498 |
|
1499 | var name_1 = tokens[0];
|
1500 | block = this._parseKeyframeBlock(delimiters);
|
1501 | span = this._generateSourceSpan(startToken, block);
|
1502 | return new CssKeyframeRuleAst(span, name_1, block);
|
1503 | case BlockType.MediaQuery:
|
1504 | this._scanner.setMode(CssLexerMode.MEDIA_QUERY);
|
1505 | tokens = this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG);
|
1506 | endToken = tokens[tokens.length - 1];
|
1507 |
|
1508 |
|
1509 | end = endToken.index + endToken.strValue.length - 1;
|
1510 | strValue = this._extractSourceContent(start, end);
|
1511 | span = this._generateSourceSpan(startToken, endToken);
|
1512 | query = new CssAtRulePredicateAst(span, strValue, tokens);
|
1513 | block = this._parseBlock(delimiters);
|
1514 | strValue = this._extractSourceContent(start, this._getScannerIndex() - 1);
|
1515 | span = this._generateSourceSpan(startToken, block);
|
1516 | return new CssMediaQueryRuleAst(span, strValue, query, block);
|
1517 | case BlockType.Document:
|
1518 | case BlockType.Supports:
|
1519 | case BlockType.Page:
|
1520 | this._scanner.setMode(CssLexerMode.AT_RULE_QUERY);
|
1521 | tokens = this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG);
|
1522 | endToken = tokens[tokens.length - 1];
|
1523 |
|
1524 |
|
1525 | end = endToken.index + endToken.strValue.length - 1;
|
1526 | strValue = this._extractSourceContent(start, end);
|
1527 | span = this._generateSourceSpan(startToken, tokens[tokens.length - 1]);
|
1528 | query = new CssAtRulePredicateAst(span, strValue, tokens);
|
1529 | block = this._parseBlock(delimiters);
|
1530 | strValue = this._extractSourceContent(start, block.end.offset);
|
1531 | span = this._generateSourceSpan(startToken, block);
|
1532 | return new CssBlockDefinitionRuleAst(span, strValue, type, query, block);
|
1533 |
|
1534 | default:
|
1535 | var listOfTokens_1 = [];
|
1536 | var tokenName = token.strValue;
|
1537 | this._scanner.setMode(CssLexerMode.ALL);
|
1538 | this._error(generateErrorMessage(this._getSourceContent(), "The CSS \"at\" rule \"" + tokenName + "\" is not allowed to used here", token.strValue, token.index, token.line, token.column), token);
|
1539 | this._collectUntilDelim(delimiters | LBRACE_DELIM_FLAG | SEMICOLON_DELIM_FLAG)
|
1540 | .forEach(function (token) { listOfTokens_1.push(token); });
|
1541 | if (this._scanner.peek == $LBRACE) {
|
1542 | listOfTokens_1.push(this._consume(CssTokenType.Character, '{'));
|
1543 | this._collectUntilDelim(delimiters | RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG)
|
1544 | .forEach(function (token) { listOfTokens_1.push(token); });
|
1545 | listOfTokens_1.push(this._consume(CssTokenType.Character, '}'));
|
1546 | }
|
1547 | endToken = listOfTokens_1[listOfTokens_1.length - 1];
|
1548 | span = this._generateSourceSpan(startToken, endToken);
|
1549 | return new CssUnknownRuleAst(span, tokenName, listOfTokens_1);
|
1550 | }
|
1551 | };
|
1552 |
|
1553 | CssParser.prototype._parseSelectorRule = function (delimiters) {
|
1554 | var start = this._getScannerIndex();
|
1555 | var selectors = this._parseSelectors(delimiters);
|
1556 | var block = this._parseStyleBlock(delimiters);
|
1557 | var ruleAst;
|
1558 | var span;
|
1559 | var startSelector = selectors[0];
|
1560 | if (block) {
|
1561 | var span = this._generateSourceSpan(startSelector, block);
|
1562 | ruleAst = new CssSelectorRuleAst(span, selectors, block);
|
1563 | }
|
1564 | else {
|
1565 | var name = this._extractSourceContent(start, this._getScannerIndex() - 1);
|
1566 | var innerTokens = [];
|
1567 | selectors.forEach(function (selector) {
|
1568 | selector.selectorParts.forEach(function (part) {
|
1569 | part.tokens.forEach(function (token) { innerTokens.push(token); });
|
1570 | });
|
1571 | });
|
1572 | var endToken = innerTokens[innerTokens.length - 1];
|
1573 | span = this._generateSourceSpan(startSelector, endToken);
|
1574 | ruleAst = new CssUnknownTokenListAst(span, name, innerTokens);
|
1575 | }
|
1576 | this._scanner.setMode(CssLexerMode.BLOCK);
|
1577 | this._scanner.consumeEmptyStatements();
|
1578 | return ruleAst;
|
1579 | };
|
1580 |
|
1581 | CssParser.prototype._parseSelectors = function (delimiters) {
|
1582 | delimiters |= LBRACE_DELIM_FLAG | SEMICOLON_DELIM_FLAG;
|
1583 | var selectors = [];
|
1584 | var isParsingSelectors = true;
|
1585 | while (isParsingSelectors) {
|
1586 | selectors.push(this._parseSelector(delimiters));
|
1587 | isParsingSelectors = !characterContainsDelimiter(this._scanner.peek, delimiters);
|
1588 | if (isParsingSelectors) {
|
1589 | this._consume(CssTokenType.Character, ',');
|
1590 | isParsingSelectors = !characterContainsDelimiter(this._scanner.peek, delimiters);
|
1591 | if (isParsingSelectors) {
|
1592 | this._scanner.consumeWhitespace();
|
1593 | }
|
1594 | }
|
1595 | }
|
1596 | return selectors;
|
1597 | };
|
1598 |
|
1599 | CssParser.prototype._scan = function () {
|
1600 | var output = this._scanner.scan();
|
1601 | var token = output.token;
|
1602 | var error = output.error;
|
1603 | if (error) {
|
1604 | this._error(error.rawMessage, token);
|
1605 | }
|
1606 | this._lastToken = token;
|
1607 | return token;
|
1608 | };
|
1609 |
|
1610 | CssParser.prototype._getScannerIndex = function () { return this._scanner.index; };
|
1611 |
|
1612 | CssParser.prototype._consume = function (type, value) {
|
1613 | if (value === void 0) { value = null; }
|
1614 | var output = this._scanner.consume(type, value);
|
1615 | var token = output.token;
|
1616 | var error = output.error;
|
1617 | if (error) {
|
1618 | this._error(error.rawMessage, token);
|
1619 | }
|
1620 | this._lastToken = token;
|
1621 | return token;
|
1622 | };
|
1623 |
|
1624 | CssParser.prototype._parseKeyframeBlock = function (delimiters) {
|
1625 | delimiters |= RBRACE_DELIM_FLAG;
|
1626 | this._scanner.setMode(CssLexerMode.KEYFRAME_BLOCK);
|
1627 | var startToken = this._consume(CssTokenType.Character, '{');
|
1628 | var definitions = [];
|
1629 | while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1630 | definitions.push(this._parseKeyframeDefinition(delimiters));
|
1631 | }
|
1632 | var endToken = this._consume(CssTokenType.Character, '}');
|
1633 | var span = this._generateSourceSpan(startToken, endToken);
|
1634 | return new CssBlockAst(span, definitions);
|
1635 | };
|
1636 |
|
1637 | CssParser.prototype._parseKeyframeDefinition = function (delimiters) {
|
1638 | var start = this._getScannerIndex();
|
1639 | var stepTokens = [];
|
1640 | delimiters |= LBRACE_DELIM_FLAG;
|
1641 | while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1642 | stepTokens.push(this._parseKeyframeLabel(delimiters | COMMA_DELIM_FLAG));
|
1643 | if (this._scanner.peek != $LBRACE) {
|
1644 | this._consume(CssTokenType.Character, ',');
|
1645 | }
|
1646 | }
|
1647 | var stylesBlock = this._parseStyleBlock(delimiters | RBRACE_DELIM_FLAG);
|
1648 | var span = this._generateSourceSpan(stepTokens[0], stylesBlock);
|
1649 | var ast = new CssKeyframeDefinitionAst(span, stepTokens, stylesBlock);
|
1650 | this._scanner.setMode(CssLexerMode.BLOCK);
|
1651 | return ast;
|
1652 | };
|
1653 |
|
1654 | CssParser.prototype._parseKeyframeLabel = function (delimiters) {
|
1655 | this._scanner.setMode(CssLexerMode.KEYFRAME_BLOCK);
|
1656 | return mergeTokens(this._collectUntilDelim(delimiters));
|
1657 | };
|
1658 |
|
1659 | CssParser.prototype._parsePseudoSelector = function (delimiters) {
|
1660 | var start = this._getScannerIndex();
|
1661 | delimiters &= ~COMMA_DELIM_FLAG;
|
1662 |
|
1663 | var startingDelims = delimiters;
|
1664 | var startToken = this._consume(CssTokenType.Character, ':');
|
1665 | var tokens = [startToken];
|
1666 | if (this._scanner.peek == $COLON) {
|
1667 | tokens.push(this._consume(CssTokenType.Character, ':'));
|
1668 | }
|
1669 | var innerSelectors = [];
|
1670 | this._scanner.setMode(CssLexerMode.PSEUDO_SELECTOR);
|
1671 |
|
1672 | var pseudoSelectorToken = this._consume(CssTokenType.Identifier);
|
1673 | var pseudoSelectorName = pseudoSelectorToken.strValue;
|
1674 | tokens.push(pseudoSelectorToken);
|
1675 |
|
1676 | if (this._scanner.peek == $LPAREN) {
|
1677 | this._scanner.setMode(CssLexerMode.PSEUDO_SELECTOR_WITH_ARGUMENTS);
|
1678 | var openParenToken = this._consume(CssTokenType.Character, '(');
|
1679 | tokens.push(openParenToken);
|
1680 |
|
1681 | if (_pseudoSelectorSupportsInnerSelectors(pseudoSelectorName)) {
|
1682 | var innerDelims = startingDelims | LPAREN_DELIM_FLAG | RPAREN_DELIM_FLAG;
|
1683 | if (pseudoSelectorName == 'not') {
|
1684 |
|
1685 |
|
1686 |
|
1687 | innerDelims |= COMMA_DELIM_FLAG;
|
1688 | }
|
1689 |
|
1690 | this._parseSelectors(innerDelims).forEach(function (selector, index) {
|
1691 | innerSelectors.push(selector);
|
1692 | });
|
1693 | }
|
1694 | else {
|
1695 |
|
1696 |
|
1697 | var innerValueDelims = delimiters | LBRACE_DELIM_FLAG | COLON_DELIM_FLAG |
|
1698 | RPAREN_DELIM_FLAG | LPAREN_DELIM_FLAG;
|
1699 | while (!characterContainsDelimiter(this._scanner.peek, innerValueDelims)) {
|
1700 | var token = this._scan();
|
1701 | tokens.push(token);
|
1702 | }
|
1703 | }
|
1704 | var closeParenToken = this._consume(CssTokenType.Character, ')');
|
1705 | tokens.push(closeParenToken);
|
1706 | }
|
1707 | var end = this._getScannerIndex() - 1;
|
1708 | var strValue = this._extractSourceContent(start, end);
|
1709 | var endToken = tokens[tokens.length - 1];
|
1710 | var span = this._generateSourceSpan(startToken, endToken);
|
1711 | return new CssPseudoSelectorAst(span, strValue, pseudoSelectorName, tokens, innerSelectors);
|
1712 | };
|
1713 |
|
1714 | CssParser.prototype._parseSimpleSelector = function (delimiters) {
|
1715 | var start = this._getScannerIndex();
|
1716 | delimiters |= COMMA_DELIM_FLAG;
|
1717 | this._scanner.setMode(CssLexerMode.SELECTOR);
|
1718 | var selectorCssTokens = [];
|
1719 | var pseudoSelectors = [];
|
1720 | var previousToken;
|
1721 | var selectorPartDelimiters = delimiters | SPACE_DELIM_FLAG;
|
1722 | var loopOverSelector = !characterContainsDelimiter(this._scanner.peek, selectorPartDelimiters);
|
1723 | var hasAttributeError = false;
|
1724 | while (loopOverSelector) {
|
1725 | var peek = this._scanner.peek;
|
1726 | switch (peek) {
|
1727 | case $COLON:
|
1728 | var innerPseudo = this._parsePseudoSelector(delimiters);
|
1729 | pseudoSelectors.push(innerPseudo);
|
1730 | this._scanner.setMode(CssLexerMode.SELECTOR);
|
1731 | break;
|
1732 | case $LBRACKET:
|
1733 |
|
1734 |
|
1735 |
|
1736 | selectorCssTokens.push(this._scan());
|
1737 | this._scanner.setMode(CssLexerMode.ATTRIBUTE_SELECTOR);
|
1738 | break;
|
1739 | case $RBRACKET:
|
1740 | if (this._scanner.getMode() != CssLexerMode.ATTRIBUTE_SELECTOR) {
|
1741 | hasAttributeError = true;
|
1742 | }
|
1743 |
|
1744 |
|
1745 | this._scanner.setMode(CssLexerMode.SELECTOR);
|
1746 | selectorCssTokens.push(this._scan());
|
1747 | break;
|
1748 | default:
|
1749 | if (isSelectorOperatorCharacter(peek)) {
|
1750 | loopOverSelector = false;
|
1751 | continue;
|
1752 | }
|
1753 | var token = this._scan();
|
1754 | previousToken = token;
|
1755 | selectorCssTokens.push(token);
|
1756 | break;
|
1757 | }
|
1758 | loopOverSelector = !characterContainsDelimiter(this._scanner.peek, selectorPartDelimiters);
|
1759 | }
|
1760 | hasAttributeError =
|
1761 | hasAttributeError || this._scanner.getMode() == CssLexerMode.ATTRIBUTE_SELECTOR;
|
1762 | if (hasAttributeError) {
|
1763 | this._error("Unbalanced CSS attribute selector at column " + previousToken.line + ":" + previousToken.column, previousToken);
|
1764 | }
|
1765 | var end = this._getScannerIndex() - 1;
|
1766 |
|
1767 |
|
1768 | if (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1769 | var operator = null;
|
1770 | var operatorScanCount = 0;
|
1771 | var lastOperatorToken = null;
|
1772 | while (operator == null && !characterContainsDelimiter(this._scanner.peek, delimiters) &&
|
1773 | isSelectorOperatorCharacter(this._scanner.peek)) {
|
1774 | var token = this._scan();
|
1775 | var tokenOperator = token.strValue;
|
1776 | operatorScanCount++;
|
1777 | lastOperatorToken = token;
|
1778 | if (tokenOperator != SPACE_OPERATOR) {
|
1779 | switch (tokenOperator) {
|
1780 | case SLASH_CHARACTER:
|
1781 |
|
1782 | var deepToken = this._consume(CssTokenType.Identifier);
|
1783 | var deepSlash = this._consume(CssTokenType.Character);
|
1784 | var index = lastOperatorToken.index;
|
1785 | var line = lastOperatorToken.line;
|
1786 | var column = lastOperatorToken.column;
|
1787 | if (deepToken && deepToken.strValue.toLowerCase() == 'deep' &&
|
1788 | deepSlash.strValue == SLASH_CHARACTER) {
|
1789 | token = new CssToken(lastOperatorToken.index, lastOperatorToken.column, lastOperatorToken.line, CssTokenType.Identifier, DEEP_OPERATOR_STR);
|
1790 | }
|
1791 | else {
|
1792 | var text = SLASH_CHARACTER + deepToken.strValue + deepSlash.strValue;
|
1793 | this._error(generateErrorMessage(this._getSourceContent(), text + " is an invalid CSS operator", text, index, line, column), lastOperatorToken);
|
1794 | token = new CssToken(index, column, line, CssTokenType.Invalid, text);
|
1795 | }
|
1796 | break;
|
1797 | case GT_CHARACTER:
|
1798 |
|
1799 | if (this._scanner.peek == $GT && this._scanner.peekPeek == $GT) {
|
1800 | this._consume(CssTokenType.Character, GT_CHARACTER);
|
1801 | this._consume(CssTokenType.Character, GT_CHARACTER);
|
1802 | token = new CssToken(lastOperatorToken.index, lastOperatorToken.column, lastOperatorToken.line, CssTokenType.Identifier, TRIPLE_GT_OPERATOR_STR);
|
1803 | }
|
1804 | break;
|
1805 | }
|
1806 | operator = token;
|
1807 | }
|
1808 | }
|
1809 |
|
1810 |
|
1811 |
|
1812 | if (operator) {
|
1813 | end = operator.index;
|
1814 | }
|
1815 | }
|
1816 | this._scanner.consumeWhitespace();
|
1817 | var strValue = this._extractSourceContent(start, end);
|
1818 |
|
1819 |
|
1820 |
|
1821 | if (operator == null && operatorScanCount > 0 && this._scanner.peek != $LBRACE) {
|
1822 | operator = lastOperatorToken;
|
1823 | }
|
1824 |
|
1825 |
|
1826 | var startTokenOrAst = null;
|
1827 | var endTokenOrAst = null;
|
1828 | if (selectorCssTokens.length > 0) {
|
1829 | startTokenOrAst = startTokenOrAst || selectorCssTokens[0];
|
1830 | endTokenOrAst = selectorCssTokens[selectorCssTokens.length - 1];
|
1831 | }
|
1832 | if (pseudoSelectors.length > 0) {
|
1833 | startTokenOrAst = startTokenOrAst || pseudoSelectors[0];
|
1834 | endTokenOrAst = pseudoSelectors[pseudoSelectors.length - 1];
|
1835 | }
|
1836 | if (operator) {
|
1837 | startTokenOrAst = startTokenOrAst || operator;
|
1838 | endTokenOrAst = operator;
|
1839 | }
|
1840 | var span = this._generateSourceSpan(startTokenOrAst, endTokenOrAst);
|
1841 | return new CssSimpleSelectorAst(span, selectorCssTokens, strValue, pseudoSelectors, operator);
|
1842 | };
|
1843 |
|
1844 | CssParser.prototype._parseSelector = function (delimiters) {
|
1845 | delimiters |= COMMA_DELIM_FLAG;
|
1846 | this._scanner.setMode(CssLexerMode.SELECTOR);
|
1847 | var simpleSelectors = [];
|
1848 | while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1849 | simpleSelectors.push(this._parseSimpleSelector(delimiters));
|
1850 | this._scanner.consumeWhitespace();
|
1851 | }
|
1852 | var firstSelector = simpleSelectors[0];
|
1853 | var lastSelector = simpleSelectors[simpleSelectors.length - 1];
|
1854 | var span = this._generateSourceSpan(firstSelector, lastSelector);
|
1855 | return new CssSelectorAst(span, simpleSelectors);
|
1856 | };
|
1857 |
|
1858 | CssParser.prototype._parseValue = function (delimiters) {
|
1859 | delimiters |= RBRACE_DELIM_FLAG | SEMICOLON_DELIM_FLAG | NEWLINE_DELIM_FLAG;
|
1860 | this._scanner.setMode(CssLexerMode.STYLE_VALUE);
|
1861 | var start = this._getScannerIndex();
|
1862 | var tokens = [];
|
1863 | var wsStr = '';
|
1864 | var previous;
|
1865 | while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1866 | var token;
|
1867 | if (previous && previous.type == CssTokenType.Identifier &&
|
1868 | this._scanner.peek == $LPAREN) {
|
1869 | token = this._consume(CssTokenType.Character, '(');
|
1870 | tokens.push(token);
|
1871 | this._scanner.setMode(CssLexerMode.STYLE_VALUE_FUNCTION);
|
1872 | token = this._scan();
|
1873 | tokens.push(token);
|
1874 | this._scanner.setMode(CssLexerMode.STYLE_VALUE);
|
1875 | token = this._consume(CssTokenType.Character, ')');
|
1876 | tokens.push(token);
|
1877 | }
|
1878 | else {
|
1879 | token = this._scan();
|
1880 | if (token.type == CssTokenType.Whitespace) {
|
1881 | wsStr += token.strValue;
|
1882 | }
|
1883 | else {
|
1884 | wsStr = '';
|
1885 | tokens.push(token);
|
1886 | }
|
1887 | }
|
1888 | previous = token;
|
1889 | }
|
1890 | var end = this._getScannerIndex() - 1;
|
1891 | this._scanner.consumeWhitespace();
|
1892 | var code = this._scanner.peek;
|
1893 | if (code == $SEMICOLON) {
|
1894 | this._consume(CssTokenType.Character, ';');
|
1895 | }
|
1896 | else if (code != $RBRACE) {
|
1897 | this._error(generateErrorMessage(this._getSourceContent(), "The CSS key/value definition did not end with a semicolon", previous.strValue, previous.index, previous.line, previous.column), previous);
|
1898 | }
|
1899 | var strValue = this._extractSourceContent(start, end);
|
1900 | var startToken = tokens[0];
|
1901 | var endToken = tokens[tokens.length - 1];
|
1902 | var span = this._generateSourceSpan(startToken, endToken);
|
1903 | return new CssStyleValueAst(span, tokens, strValue);
|
1904 | };
|
1905 |
|
1906 | CssParser.prototype._collectUntilDelim = function (delimiters, assertType) {
|
1907 | if (assertType === void 0) { assertType = null; }
|
1908 | var tokens = [];
|
1909 | while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1910 | var val = assertType ? this._consume(assertType) : this._scan();
|
1911 | tokens.push(val);
|
1912 | }
|
1913 | return tokens;
|
1914 | };
|
1915 |
|
1916 | CssParser.prototype._parseBlock = function (delimiters) {
|
1917 | delimiters |= RBRACE_DELIM_FLAG;
|
1918 | this._scanner.setMode(CssLexerMode.BLOCK);
|
1919 | var startToken = this._consume(CssTokenType.Character, '{');
|
1920 | this._scanner.consumeEmptyStatements();
|
1921 | var results = [];
|
1922 | while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1923 | results.push(this._parseRule(delimiters));
|
1924 | }
|
1925 | var endToken = this._consume(CssTokenType.Character, '}');
|
1926 | this._scanner.setMode(CssLexerMode.BLOCK);
|
1927 | this._scanner.consumeEmptyStatements();
|
1928 | var span = this._generateSourceSpan(startToken, endToken);
|
1929 | return new CssBlockAst(span, results);
|
1930 | };
|
1931 |
|
1932 | CssParser.prototype._parseStyleBlock = function (delimiters) {
|
1933 | delimiters |= RBRACE_DELIM_FLAG | LBRACE_DELIM_FLAG;
|
1934 | this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
|
1935 | var startToken = this._consume(CssTokenType.Character, '{');
|
1936 | if (startToken.numValue != $LBRACE) {
|
1937 | return null;
|
1938 | }
|
1939 | var definitions = [];
|
1940 | this._scanner.consumeEmptyStatements();
|
1941 | while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
|
1942 | definitions.push(this._parseDefinition(delimiters));
|
1943 | this._scanner.consumeEmptyStatements();
|
1944 | }
|
1945 | var endToken = this._consume(CssTokenType.Character, '}');
|
1946 | this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
|
1947 | this._scanner.consumeEmptyStatements();
|
1948 | var span = this._generateSourceSpan(startToken, endToken);
|
1949 | return new CssStylesBlockAst(span, definitions);
|
1950 | };
|
1951 |
|
1952 | CssParser.prototype._parseDefinition = function (delimiters) {
|
1953 | this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
|
1954 | var prop = this._consume(CssTokenType.Identifier);
|
1955 | var parseValue = false;
|
1956 | var value = null;
|
1957 | var endToken = prop;
|
1958 |
|
1959 |
|
1960 |
|
1961 | switch (this._scanner.peek) {
|
1962 | case $SEMICOLON:
|
1963 | case $RBRACE:
|
1964 | case $EOF:
|
1965 | parseValue = false;
|
1966 | break;
|
1967 | default:
|
1968 | var propStr = [prop.strValue];
|
1969 | if (this._scanner.peek != $COLON) {
|
1970 |
|
1971 | var nextValue = this._consume(CssTokenType.Character, ':');
|
1972 | propStr.push(nextValue.strValue);
|
1973 | var remainingTokens = this._collectUntilDelim(delimiters | COLON_DELIM_FLAG | SEMICOLON_DELIM_FLAG, CssTokenType.Identifier);
|
1974 | if (remainingTokens.length > 0) {
|
1975 | remainingTokens.forEach(function (token) { propStr.push(token.strValue); });
|
1976 | }
|
1977 | endToken = prop =
|
1978 | new CssToken(prop.index, prop.column, prop.line, prop.type, propStr.join(' '));
|
1979 | }
|
1980 |
|
1981 | if (this._scanner.peek == $COLON) {
|
1982 | this._consume(CssTokenType.Character, ':');
|
1983 | parseValue = true;
|
1984 | }
|
1985 | break;
|
1986 | }
|
1987 | if (parseValue) {
|
1988 | value = this._parseValue(delimiters);
|
1989 | endToken = value;
|
1990 | }
|
1991 | else {
|
1992 | this._error(generateErrorMessage(this._getSourceContent(), "The CSS property was not paired with a style value", prop.strValue, prop.index, prop.line, prop.column), prop);
|
1993 | }
|
1994 | var span = this._generateSourceSpan(prop, endToken);
|
1995 | return new CssDefinitionAst(span, prop, value);
|
1996 | };
|
1997 |
|
1998 | CssParser.prototype._assertCondition = function (status, errorMessage, problemToken) {
|
1999 | if (!status) {
|
2000 | this._error(errorMessage, problemToken);
|
2001 | return true;
|
2002 | }
|
2003 | return false;
|
2004 | };
|
2005 |
|
2006 | CssParser.prototype._error = function (message, problemToken) {
|
2007 | var length = problemToken.strValue.length;
|
2008 | var error = CssParseError.create(this._file, 0, problemToken.line, problemToken.column, length, message);
|
2009 | this._errors.push(error);
|
2010 | };
|
2011 | return CssParser;
|
2012 | }());
|
2013 | var CssParseError = (function (_super) {
|
2014 | __extends$3(CssParseError, _super);
|
2015 | function CssParseError(span, message) {
|
2016 | return _super.call(this, span, message) || this;
|
2017 | }
|
2018 | CssParseError.create = function (file, offset, line, col, length, errMsg) {
|
2019 | var start = new ParseLocation(file, offset, line, col);
|
2020 | var end = new ParseLocation(file, offset, line, col + length);
|
2021 | var span = new ParseSourceSpan(start, end);
|
2022 | return new CssParseError(span, 'CSS Parse Error: ' + errMsg);
|
2023 | };
|
2024 | return CssParseError;
|
2025 | }(ParseError));
|
2026 |
|
2027 | var parseCss = function (text) {
|
2028 | var parser = new CssParser();
|
2029 | return parser.parse(text, '').ast;
|
2030 | };
|
2031 |
|
2032 | var __extends$2 = (undefined && undefined.__extends) || (function () {
|
2033 | var extendStatics = Object.setPrototypeOf ||
|
2034 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
2035 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
2036 | return function (d, b) {
|
2037 | extendStatics(d, b);
|
2038 | function __() { this.constructor = d; }
|
2039 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
2040 | };
|
2041 | })();
|
2042 |
|
2043 |
|
2044 |
|
2045 |
|
2046 |
|
2047 |
|
2048 |
|
2049 |
|
2050 | var DirectiveSymbol = (function (_super) {
|
2051 | __extends$2(DirectiveSymbol, _super);
|
2052 | |
2053 |
|
2054 |
|
2055 |
|
2056 |
|
2057 |
|
2058 |
|
2059 |
|
2060 |
|
2061 |
|
2062 |
|
2063 |
|
2064 |
|
2065 |
|
2066 | function DirectiveSymbol(program, symbol, metadataResolver, directiveNormalizer, resolver, reflector, resourceResolver, projectSymbols) {
|
2067 | var _this = _super.call(this, program, symbol) || this;
|
2068 | _this.metadataResolver = metadataResolver;
|
2069 | _this.directiveNormalizer = directiveNormalizer;
|
2070 | _this.resolver = resolver;
|
2071 | _this.reflector = reflector;
|
2072 | _this.resourceResolver = resourceResolver;
|
2073 | _this.projectSymbols = projectSymbols;
|
2074 | _this.urlResolver = new _angular_compiler.UrlResolver();
|
2075 | return _this;
|
2076 | }
|
2077 | |
2078 |
|
2079 |
|
2080 |
|
2081 |
|
2082 |
|
2083 |
|
2084 |
|
2085 |
|
2086 |
|
2087 | DirectiveSymbol.prototype.getNonResolvedMetadata = function () {
|
2088 | return this.metadataResolver.getNonNormalizedDirectiveMetadata(this.symbol).metadata;
|
2089 | };
|
2090 |
|
2091 | |
2092 |
|
2093 |
|
2094 |
|
2095 |
|
2096 |
|
2097 |
|
2098 |
|
2099 |
|
2100 | DirectiveSymbol.prototype.getResolvedMetadata = function () {
|
2101 | var _this = this;
|
2102 | var metadata = this.metadataResolver.getNonNormalizedDirectiveMetadata(this.symbol);
|
2103 | var componentType = _angular_core.resolveForwardRef(this.symbol);
|
2104 | var componentUrl = _angular_compiler.componentModuleUrl(this.reflector, componentType, metadata);
|
2105 | var templateMetadata = metadata.metadata.template;
|
2106 |
|
2107 | if (!templateMetadata.template) {
|
2108 | templateMetadata.templateUrl = this.urlResolver.resolve(componentUrl, templateMetadata.templateUrl);
|
2109 | templateMetadata.template = this.resourceResolver.getSync(templateMetadata.templateUrl);
|
2110 | }
|
2111 | var currentMetadata = this.directiveNormalizer.normalizeTemplateSync(Object.assign(templateMetadata, {
|
2112 | ngModuleType: this.getModule().type.reference,
|
2113 | moduleUrl: componentUrl,
|
2114 | componentType: componentType
|
2115 | }));
|
2116 | if (templateMetadata.templateUrl) {
|
2117 | currentMetadata.template = this.resourceResolver.getSync(templateMetadata.templateUrl);
|
2118 | currentMetadata.templateUrl = templateMetadata.templateUrl;
|
2119 | }
|
2120 | currentMetadata.styles = currentMetadata.styles.concat(currentMetadata.styleUrls.map(function (path) {
|
2121 | return _this.resourceResolver.getSync(path);
|
2122 | }));
|
2123 | return currentMetadata;
|
2124 | };
|
2125 | |
2126 |
|
2127 |
|
2128 |
|
2129 |
|
2130 |
|
2131 |
|
2132 | DirectiveSymbol.prototype.getModule = function () {
|
2133 | return this.projectSymbols
|
2134 | .getAnalyzedModules().ngModuleByPipeOrDirective.get(this.symbol);
|
2135 | };
|
2136 | |
2137 |
|
2138 |
|
2139 |
|
2140 |
|
2141 |
|
2142 |
|
2143 | DirectiveSymbol.prototype.getStyleAsts = function () {
|
2144 | return this.getResolvedMetadata()
|
2145 | .styles.map(function (s) { return parseCss(s); });
|
2146 | };
|
2147 | |
2148 |
|
2149 |
|
2150 |
|
2151 |
|
2152 |
|
2153 |
|
2154 |
|
2155 | DirectiveSymbol.prototype.getDirectiveContext = function () {
|
2156 | var _this = this;
|
2157 | var analyzedModules = this.projectSymbols.getAnalyzedModules();
|
2158 | var ngModule = analyzedModules.ngModuleByPipeOrDirective.get(this.symbol);
|
2159 | if (!ngModule) {
|
2160 | throw new Error('Cannot find module associated with the directive ' + this.symbol.name);
|
2161 | }
|
2162 | var resolvedDirectives = ngModule.transitiveModule.directives.map(function (d) { return _this.metadataResolver.getNonNormalizedDirectiveMetadata(d.reference); });
|
2163 | var directives = resolvedDirectives.filter(function (d) { return d !== null; }).map(function (d) { return d.metadata.toSummary(); });
|
2164 | var pipes = ngModule.transitiveModule.pipes.map(function (p) { return _this.metadataResolver.getOrLoadPipeMetadata(p.reference).toSummary(); });
|
2165 | var schemas = ngModule.schemas;
|
2166 | return {
|
2167 | pipes: pipes, directives: directives, schemas: schemas
|
2168 | };
|
2169 | };
|
2170 | |
2171 |
|
2172 |
|
2173 |
|
2174 |
|
2175 |
|
2176 |
|
2177 | DirectiveSymbol.prototype.getTemplateAst = function () {
|
2178 | var result;
|
2179 | try {
|
2180 | var resolvedMetadata = this.metadataResolver.getNonNormalizedDirectiveMetadata(this.symbol);
|
2181 | var dirMetadata = this.getResolvedMetadata();
|
2182 | var source = dirMetadata.template;
|
2183 | var metadata = resolvedMetadata && resolvedMetadata.metadata;
|
2184 | if (metadata) {
|
2185 | var rawHtmlParser = new _angular_compiler.HtmlParser();
|
2186 | var htmlParser = new _angular_compiler.I18NHtmlParser(rawHtmlParser);
|
2187 | var expressionParser = new _angular_compiler.Parser(new _angular_compiler.Lexer());
|
2188 | var parser = void 0;
|
2189 | parser = new _angular_compiler.TemplateParser(new _angular_compiler.CompilerConfig, expressionParser, new _angular_compiler.DomElementSchemaRegistry(), htmlParser, undefined, []);
|
2190 | var htmlResult = htmlParser.parse(source, '');
|
2191 | var _a = this.getDirectiveContext(), directives = _a.directives, pipes = _a.pipes, schemas = _a.schemas;
|
2192 | var parseResult = parser.tryParseHtml(htmlResult, metadata, directives, pipes, schemas);
|
2193 | result = {
|
2194 | templateAst: parseResult.templateAst,
|
2195 | parseErrors: parseResult.errors,
|
2196 | errors: []
|
2197 | };
|
2198 | }
|
2199 | else {
|
2200 | result = { errors: [{ message: 'Cannot find metadata for the directive' }] };
|
2201 | }
|
2202 | }
|
2203 | catch (e) {
|
2204 | result = { errors: [{ message: e.message }] };
|
2205 | }
|
2206 | return result;
|
2207 | };
|
2208 | DirectiveSymbol.prototype.getDependencies = function () {
|
2209 | var _this = this;
|
2210 | var summary = this.metadataResolver.getInjectableSummary(this.symbol);
|
2211 | if (!summary) {
|
2212 | return [];
|
2213 | }
|
2214 | else {
|
2215 | return (summary.type.diDeps || []).map(function (d) {
|
2216 | var meta = new _angular_compiler.ProviderMeta(d.token.identifier.reference, d);
|
2217 | return new ProviderSymbol(_this._program, _this.metadataResolver.getProviderMetadata(meta), _this.metadataResolver);
|
2218 | });
|
2219 | }
|
2220 | };
|
2221 | DirectiveSymbol.prototype.getProviders = function () {
|
2222 | var _this = this;
|
2223 | return (this.getNonResolvedMetadata().providers || []).map(function (d) {
|
2224 | return new ProviderSymbol(_this._program, d, _this.metadataResolver);
|
2225 | });
|
2226 | };
|
2227 | DirectiveSymbol.prototype.getViewProviders = function () {
|
2228 | var _this = this;
|
2229 | return (this.getNonResolvedMetadata().viewProviders || []).map(function (d) {
|
2230 | return new ProviderSymbol(_this._program, d, _this.metadataResolver);
|
2231 | });
|
2232 | };
|
2233 | |
2234 |
|
2235 |
|
2236 |
|
2237 |
|
2238 |
|
2239 |
|
2240 | DirectiveSymbol.prototype.isComponent = function () {
|
2241 | return !!this.getResolvedMetadata().template;
|
2242 | };
|
2243 | return DirectiveSymbol;
|
2244 | }(Symbol));
|
2245 |
|
2246 | var __extends$5 = (undefined && undefined.__extends) || (function () {
|
2247 | var extendStatics = Object.setPrototypeOf ||
|
2248 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
2249 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
2250 | return function (d, b) {
|
2251 | extendStatics(d, b);
|
2252 | function __() { this.constructor = d; }
|
2253 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
2254 | };
|
2255 | })();
|
2256 | var ModuleSymbol = (function (_super) {
|
2257 | __extends$5(ModuleSymbol, _super);
|
2258 | function ModuleSymbol(program, symbol, metadataResolver, directiveNormalizer, resolver, pipeResolver, reflector, resourceResolver, projectSymbols) {
|
2259 | var _this = _super.call(this, program, symbol) || this;
|
2260 | _this.metadataResolver = metadataResolver;
|
2261 | _this.directiveNormalizer = directiveNormalizer;
|
2262 | _this.resolver = resolver;
|
2263 | _this.pipeResolver = pipeResolver;
|
2264 | _this.reflector = reflector;
|
2265 | _this.resourceResolver = resourceResolver;
|
2266 | _this.projectSymbols = projectSymbols;
|
2267 | _this.module = _this.metadataResolver.getNgModuleMetadata(symbol);
|
2268 | return _this;
|
2269 | }
|
2270 | ModuleSymbol.prototype.getBootstrapComponents = function () {
|
2271 | return this.getWrapperDirectives(this.module.bootstrapComponents);
|
2272 | };
|
2273 | ModuleSymbol.prototype.getDeclaredDirectives = function () {
|
2274 | return this.getWrapperDirectives(this.module.declaredDirectives);
|
2275 | };
|
2276 | ModuleSymbol.prototype.getExportedDirectives = function () {
|
2277 | return this.getWrapperDirectives(this.module.exportedDirectives);
|
2278 | };
|
2279 | ModuleSymbol.prototype.getExportedPipes = function () {
|
2280 | return this.getWrappedPipes(this.module.exportedPipes);
|
2281 | };
|
2282 | ModuleSymbol.prototype.getDeclaredPipes = function () {
|
2283 | return this.getWrappedPipes(this.module.declaredPipes);
|
2284 | };
|
2285 | ModuleSymbol.prototype.getImportedModules = function () {
|
2286 | return this.getWrappedModules(this.module.importedModules);
|
2287 | };
|
2288 | ModuleSymbol.prototype.getExportedModules = function () {
|
2289 | return this.getWrappedModules(this.module.exportedModules);
|
2290 | };
|
2291 | ModuleSymbol.prototype.getProviders = function () {
|
2292 | var _this = this;
|
2293 | return this.module.providers.map(function (p) {
|
2294 | return new ProviderSymbol(_this._program, p, _this.metadataResolver);
|
2295 | });
|
2296 | };
|
2297 | ModuleSymbol.prototype.getWrappedModules = function (modules) {
|
2298 | var _this = this;
|
2299 | return modules.map(function (s) {
|
2300 | return new ModuleSymbol(_this._program, s.type.reference, _this.metadataResolver, _this.directiveNormalizer, _this.resolver, _this.pipeResolver, _this.reflector, _this.resourceResolver, _this.projectSymbols);
|
2301 | });
|
2302 | };
|
2303 | ModuleSymbol.prototype.getWrappedPipes = function (pipes) {
|
2304 | var _this = this;
|
2305 | return pipes.map(function (i) {
|
2306 | return new PipeSymbol(_this._program, i.reference, _this.pipeResolver, _this.metadataResolver, _this.projectSymbols);
|
2307 | });
|
2308 | };
|
2309 | ModuleSymbol.prototype.getWrapperDirectives = function (dirs) {
|
2310 | var _this = this;
|
2311 | return dirs.map(function (i) {
|
2312 | return new DirectiveSymbol(_this._program, i.reference, _this.metadataResolver, _this.directiveNormalizer, _this.resolver, _this.reflector, _this.resourceResolver, _this.projectSymbols);
|
2313 | });
|
2314 | };
|
2315 | return ModuleSymbol;
|
2316 | }(Symbol));
|
2317 |
|
2318 |
|
2319 |
|
2320 |
|
2321 |
|
2322 |
|
2323 |
|
2324 |
|
2325 | var ProjectSymbols = (function () {
|
2326 | |
2327 |
|
2328 |
|
2329 |
|
2330 |
|
2331 |
|
2332 |
|
2333 |
|
2334 | function ProjectSymbols(program, resourceResolver, errorReporter) {
|
2335 | this.program = program;
|
2336 | this.resourceResolver = resourceResolver;
|
2337 | this.errorReporter = errorReporter;
|
2338 | this.options = this.program.getCompilerOptions();
|
2339 | this.init();
|
2340 | }
|
2341 | |
2342 |
|
2343 |
|
2344 |
|
2345 |
|
2346 |
|
2347 |
|
2348 | ProjectSymbols.prototype.getModules = function () {
|
2349 | var _this = this;
|
2350 | this.validate();
|
2351 | var resultMap = new Map();
|
2352 | this.getAnalyzedModules()
|
2353 | .ngModules
|
2354 | .forEach(function (m, s) {
|
2355 | resultMap.set(m.type.reference, m);
|
2356 | });
|
2357 | var result = [];
|
2358 | resultMap.forEach(function (v) { return result.push(new ModuleSymbol(_this.program, v.type.reference, _this.metadataResolver, _this.directiveNormalizer, _this.directiveResolver, _this.pipeResolver, _this.reflector, _this.resourceResolver, _this)); });
|
2359 | return result;
|
2360 | };
|
2361 | |
2362 |
|
2363 |
|
2364 |
|
2365 |
|
2366 |
|
2367 |
|
2368 | ProjectSymbols.prototype.getDirectives = function () {
|
2369 | var _this = this;
|
2370 | return this.extractProgramSymbols()
|
2371 | .filter(function (symbol) { return _this.metadataResolver.isDirective(symbol); })
|
2372 | .map(function (symbol) { return new DirectiveSymbol(_this.program, symbol, _this.metadataResolver, _this.directiveNormalizer, _this.directiveResolver, _this.reflector, _this.resourceResolver, _this); });
|
2373 | };
|
2374 | |
2375 |
|
2376 |
|
2377 |
|
2378 |
|
2379 |
|
2380 |
|
2381 | ProjectSymbols.prototype.getPipes = function () {
|
2382 | var _this = this;
|
2383 | return this.extractProgramSymbols()
|
2384 | .filter(function (v) { return _this.metadataResolver.isPipe(v); })
|
2385 | .map(function (p) { return new PipeSymbol(_this.program, p, _this.pipeResolver, _this.metadataResolver, _this); });
|
2386 | };
|
2387 | |
2388 |
|
2389 |
|
2390 |
|
2391 |
|
2392 |
|
2393 |
|
2394 | ProjectSymbols.prototype.getProviders = function () {
|
2395 | var resultSet = new Map();
|
2396 | this.getModules().forEach(function (m) {
|
2397 | m.getProviders().forEach(function (p) { return resultSet.set(p.symbol, p); });
|
2398 | });
|
2399 | this.getDirectives().forEach(function (d) {
|
2400 | d.getProviders().forEach(function (p) { return resultSet.set(p.symbol, p); });
|
2401 | d.getViewProviders().forEach(function (p) { return resultSet.set(p.symbol, p); });
|
2402 | });
|
2403 | var finalResult = [];
|
2404 | resultSet.forEach(function (v) { return finalResult.push(v); });
|
2405 | return finalResult;
|
2406 | };
|
2407 | |
2408 |
|
2409 |
|
2410 |
|
2411 |
|
2412 |
|
2413 |
|
2414 | ProjectSymbols.prototype.getContextSummary = function () {
|
2415 | var module = this.getModules().pop();
|
2416 | if (module) {
|
2417 | return this.metadataResolver.getNgModuleSummary(module.symbol);
|
2418 | }
|
2419 | return undefined;
|
2420 | };
|
2421 | |
2422 |
|
2423 |
|
2424 |
|
2425 |
|
2426 |
|
2427 |
|
2428 |
|
2429 |
|
2430 | ProjectSymbols.prototype.updateProgram = function (program) {
|
2431 | if (program !== this.program) {
|
2432 | this.program = program;
|
2433 | this.validate();
|
2434 | }
|
2435 | };
|
2436 | |
2437 |
|
2438 |
|
2439 |
|
2440 |
|
2441 |
|
2442 |
|
2443 |
|
2444 | ProjectSymbols.prototype.getDirectiveFromNode = function (declaration, fileName) {
|
2445 | var sourceFile = this.program.getSourceFile(fileName);
|
2446 | return new DirectiveSymbol(this.program, this.reflector.getStaticSymbol(sourceFile.fileName, declaration.name.text), this.metadataResolver, this.directiveNormalizer, this.directiveResolver, this.reflector, this.resourceResolver, this);
|
2447 | };
|
2448 |
|
2449 | ProjectSymbols.prototype.getAnalyzedModules = function () {
|
2450 | var analyzedModules = this.analyzedModules;
|
2451 | if (!analyzedModules) {
|
2452 | var analyzeHost = { isSourceFile: function (filePath) { return true; } };
|
2453 | var programSymbols = _angular_compiler.extractProgramSymbols(this.staticSymbolResolver, this.program.getSourceFiles().map(function (sf) { return sf.fileName; }), analyzeHost);
|
2454 | analyzedModules = this.analyzedModules =
|
2455 | _angular_compiler.analyzeNgModules(programSymbols, analyzeHost, this.metadataResolver);
|
2456 | }
|
2457 | return analyzedModules;
|
2458 | };
|
2459 | ProjectSymbols.prototype.extractProgramSymbols = function () {
|
2460 | return _angular_compiler.extractProgramSymbols(this.staticSymbolResolver, this.program.getSourceFiles().map(function (sf) { return sf.fileName; }), {
|
2461 | isSourceFile: function () { return true; }
|
2462 | });
|
2463 | };
|
2464 | ProjectSymbols.prototype.validate = function () {
|
2465 | var program = this.program;
|
2466 | if (this.lastProgram !== program) {
|
2467 | this.clearCaches();
|
2468 | this.lastProgram = program;
|
2469 | this.init();
|
2470 | }
|
2471 | };
|
2472 | ProjectSymbols.prototype.clearCaches = function () {
|
2473 | this.metadataResolver.clearCache();
|
2474 | this.directiveNormalizer.clearCache();
|
2475 | };
|
2476 | ProjectSymbols.prototype.init = function () {
|
2477 | var staticSymbolCache = new _angular_compiler.StaticSymbolCache();
|
2478 | var summaryResolver = new _angular_compiler.AotSummaryResolver({
|
2479 | loadSummary: function (filePath) { return ''; },
|
2480 | isSourceFile: function (sourceFilePath) { return true; },
|
2481 | getOutputFileName: function () { return ''; }
|
2482 | }, staticSymbolCache);
|
2483 | var parser = new _angular_compiler.HtmlParser();
|
2484 | var config = new _angular_compiler.CompilerConfig({
|
2485 | defaultEncapsulation: _angular_core.ViewEncapsulation.Emulated,
|
2486 | useJit: false
|
2487 | });
|
2488 | var defaultDir = this.program.getCurrentDirectory();
|
2489 | this.options.baseUrl = this.options.baseUrl || defaultDir;
|
2490 | this.options.basePath = this.options.basePath || defaultDir;
|
2491 | this.options.genDir = this.options.genDir || defaultDir;
|
2492 | this.staticResolverHost = new _angular_compilerCli.CompilerHost(this.program, this.options, new _angular_compilerCli.NodeCompilerHostContext());
|
2493 | this.staticSymbolResolver = new _angular_compiler.StaticSymbolResolver(
|
2494 |
|
2495 | this.staticResolverHost, staticSymbolCache, summaryResolver, this.errorReporter);
|
2496 | this.summaryResolver = new _angular_compiler.AotSummaryResolver({
|
2497 | loadSummary: function (filePath) { return null; },
|
2498 | isSourceFile: function (sourceFilePath) { return true; },
|
2499 | getOutputFileName: function (sourceFilePath) { return null; }
|
2500 | }, staticSymbolCache);
|
2501 | this.reflector = new _angular_compiler.StaticReflector(this.summaryResolver, this.staticSymbolResolver, [], [], this.errorReporter);
|
2502 | var ngModuleResolver = new _angular_compiler.NgModuleResolver(this.reflector);
|
2503 | this.directiveResolver = new _angular_compiler.DirectiveResolver(this.reflector);
|
2504 | this.pipeResolver = new _angular_compiler.PipeResolver(this.reflector);
|
2505 | this.urlResolver = _angular_compiler.createOfflineCompileUrlResolver();
|
2506 | this.directiveNormalizer = new _angular_compiler.DirectiveNormalizer(this.resourceResolver, this.urlResolver, parser, config);
|
2507 | this.metadataResolver = new _angular_compiler.CompileMetadataResolver(new _angular_compiler.CompilerConfig(), ngModuleResolver, this.directiveResolver, this.pipeResolver, summaryResolver, new _angular_compiler.DomElementSchemaRegistry(), this.directiveNormalizer, new _angular_core.ɵConsole(), staticSymbolCache, this.reflector);
|
2508 | };
|
2509 | return ProjectSymbols;
|
2510 | }());
|
2511 |
|
2512 | exports.ProjectSymbols = ProjectSymbols;
|
2513 | exports.ModuleSymbol = ModuleSymbol;
|
2514 | exports.ProviderSymbol = ProviderSymbol;
|
2515 | exports.DirectiveSymbol = DirectiveSymbol;
|
2516 | exports.PipeSymbol = PipeSymbol;
|
2517 | exports.Symbol = Symbol;
|
2518 |
|
2519 | Object.defineProperty(exports, '__esModule', { value: true });
|
2520 |
|
2521 | })));
|