cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(): use const and let instead of var

Browse Source
This commit is contained in:
Joao Dias
2016-11-12 14:08:58 +01:00
committed by Victor Berchet
parent 73593d4bf3
commit 77ee27c59e
435 changed files with 4637 additions and 4663 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
modules/@angular/compiler/src/css_parser/css_ast.ts
View File

@ -96,7 +96,7 @@ export class CssBlockDefinitionRuleAst extends CssBlockRuleAst {
location: ParseSourceSpan, public strValue: string, type: BlockType,
public query: CssAtRulePredicateAst, block: CssBlockAst) {
super(location, type, block);
var firstCssToken: CssToken = query.tokens[0];
const firstCssToken: CssToken = query.tokens[0];
this.name = new CssToken(
firstCssToken.index, firstCssToken.column, firstCssToken.line, CssTokenType.Identifier,
this.strValue);
@ -238,9 +238,9 @@ export class CssUnknownTokenListAst extends CssRuleAst {
}
export function mergeTokens(tokens: CssToken[], separator: string = ''): CssToken {
var mainToken = tokens[0];
var str = mainToken.strValue;
for (var i = 1; i < tokens.length; i++) {
const mainToken = tokens[0];
let str = mainToken.strValue;
for (let i = 1; i < tokens.length; i++) {
str += separator + tokens[i].strValue;
}

128
modules/@angular/compiler/src/css_parser/css_lexer.ts
View File

@ -54,18 +54,18 @@ export function generateErrorMessage(
export function findProblemCode(
input: string, errorValue: string, index: number, column: number): string {
var endOfProblemLine = index;
var current = charCode(input, index);
let endOfProblemLine = index;
let current = charCode(input, index);
while (current > 0 && !isNewline(current)) {
current = charCode(input, ++endOfProblemLine);
}
var choppedString = input.substring(0, endOfProblemLine);
var pointerPadding = '';
for (var i = 0; i < column; i++) {
const choppedString = input.substring(0, endOfProblemLine);
let pointerPadding = '';
for (let i = 0; i < column; i++) {
pointerPadding += ' ';
}
var pointerString = '';
for (var i = 0; i < errorValue.length; i++) {
let pointerString = '';
for (let i = 0; i < errorValue.length; i++) {
pointerString += '^';
}
return choppedString + '\n' + pointerPadding + pointerString + '\n';
@ -185,16 +185,16 @@ export class CssScanner {
}
consume(type: CssTokenType, value: string = null): LexedCssResult {
var mode = this._currentMode;
const mode = this._currentMode;
this.setMode(_trackWhitespace(mode) ? CssLexerMode.ALL_TRACK_WS : CssLexerMode.ALL);
var previousIndex = this.index;
var previousLine = this.line;
var previousColumn = this.column;
const previousIndex = this.index;
const previousLine = this.line;
const previousColumn = this.column;
var next: CssToken;
var output = this.scan();
let next: CssToken;
const output = this.scan();
if (isPresent(output)) {
// just incase the inner scan method returned an error
if (isPresent(output.error)) {
@ -209,7 +209,7 @@ export class CssScanner {
next = new CssToken(this.index, this.column, this.line, CssTokenType.EOF, 'end of file');
}
var isMatchingType: boolean = false;
let isMatchingType: boolean = false;
if (type == CssTokenType.IdentifierOrNumber) {
// TODO (matsko): implement array traversal for lookup here
isMatchingType = next.type == CssTokenType.Number || next.type == CssTokenType.Identifier;
@ -221,9 +221,9 @@ export class CssScanner {
// mode so that the parser can recover...
this.setMode(mode);
var error: CssScannerError = null;
let error: CssScannerError = null;
if (!isMatchingType || (isPresent(value) && value != next.strValue)) {
var errorMessage =
let errorMessage =
CssTokenType[next.type] + ' does not match expected ' + CssTokenType[type] + ' value';
if (isPresent(value)) {
@ -241,15 +241,15 @@ export class CssScanner {
scan(): LexedCssResult {
var trackWS = _trackWhitespace(this._currentMode);
const trackWS = _trackWhitespace(this._currentMode);
if (this.index == 0 && !trackWS) { // first scan
this.consumeWhitespace();
}
var token = this._scan();
const token = this._scan();
if (token == null) return null;
var error = this._currentError;
const error = this._currentError;
this._currentError = null;
if (!trackWS) {
@ -260,14 +260,14 @@ export class CssScanner {
/** @internal */
_scan(): CssToken {
var peek = this.peek;
var peekPeek = this.peekPeek;
let peek = this.peek;
let peekPeek = this.peekPeek;
if (peek == chars.$EOF) return null;
if (isCommentStart(peek, peekPeek)) {
// even if comments are not tracked we still lex the
// comment so we can move the pointer forward
var commentToken = this.scanComment();
const commentToken = this.scanComment();
if (this._trackComments) {
return commentToken;
}
@ -290,9 +290,9 @@ export class CssScanner {
return this.scanCssValueFunction();
}
var isModifier = peek == chars.$PLUS || peek == chars.$MINUS;
var digitA = isModifier ? false : chars.isDigit(peek);
var digitB = chars.isDigit(peekPeek);
const isModifier = peek == chars.$PLUS || peek == chars.$MINUS;
const digitA = isModifier ? false : chars.isDigit(peek);
const digitB = chars.isDigit(peekPeek);
if (digitA || (isModifier && (peekPeek == chars.$PERIOD || digitB)) ||
(peek == chars.$PERIOD && digitB)) {
return this.scanNumber();
@ -319,9 +319,9 @@ export class CssScanner {
return null;
}
var start = this.index;
var startingColumn = this.column;
var startingLine = this.line;
const start = this.index;
const startingColumn = this.column;
const startingLine = this.line;
this.advance(); // /
this.advance(); // *
@ -336,18 +336,18 @@ export class CssScanner {
this.advance(); // *
this.advance(); // /
var str = this.input.substring(start, this.index);
const str = this.input.substring(start, this.index);
return new CssToken(start, startingColumn, startingLine, CssTokenType.Comment, str);
}
scanWhitespace(): CssToken {
var start = this.index;
var startingColumn = this.column;
var startingLine = this.line;
const start = this.index;
const startingColumn = this.column;
const startingLine = this.line;
while (chars.isWhitespace(this.peek) && this.peek != chars.$EOF) {
this.advance();
}
var str = this.input.substring(start, this.index);
const str = this.input.substring(start, this.index);
return new CssToken(start, startingColumn, startingLine, CssTokenType.Whitespace, str);
}
@ -357,11 +357,11 @@ export class CssScanner {
return null;
}
var target = this.peek;
var start = this.index;
var startingColumn = this.column;
var startingLine = this.line;
var previous = target;
const target = this.peek;
const start = this.index;
const startingColumn = this.column;
const startingLine = this.line;
let previous = target;
this.advance();
while (!isCharMatch(target, previous, this.peek)) {
@ -377,17 +377,17 @@ export class CssScanner {
}
this.advance();
var str = this.input.substring(start, this.index);
const str = this.input.substring(start, this.index);
return new CssToken(start, startingColumn, startingLine, CssTokenType.String, str);
}
scanNumber(): CssToken {
var start = this.index;
var startingColumn = this.column;
const start = this.index;
const startingColumn = this.column;
if (this.peek == chars.$PLUS || this.peek == chars.$MINUS) {
this.advance();
}
var periodUsed = false;
let periodUsed = false;
while (chars.isDigit(this.peek) || this.peek == chars.$PERIOD) {
if (this.peek == chars.$PERIOD) {
if (periodUsed) {
@ -397,7 +397,7 @@ export class CssScanner {
}
this.advance();
}
var strValue = this.input.substring(start, this.index);
const strValue = this.input.substring(start, this.index);
return new CssToken(start, startingColumn, this.line, CssTokenType.Number, strValue);
}
@ -407,19 +407,19 @@ export class CssScanner {
return null;
}
var start = this.index;
var startingColumn = this.column;
const start = this.index;
const startingColumn = this.column;
while (isIdentifierPart(this.peek)) {
this.advance();
}
var strValue = this.input.substring(start, this.index);
const strValue = this.input.substring(start, this.index);
return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
}
scanCssValueFunction(): CssToken {
var start = this.index;
var startingColumn = this.column;
var parenBalance = 1;
const start = this.index;
const startingColumn = this.column;
let parenBalance = 1;
while (this.peek != chars.$EOF && parenBalance > 0) {
this.advance();
if (this.peek == chars.$LPAREN) {
@ -428,20 +428,20 @@ export class CssScanner {
parenBalance--;
}
}
var strValue = this.input.substring(start, this.index);
const strValue = this.input.substring(start, this.index);
return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);
}
scanCharacter(): CssToken {
var start = this.index;
var startingColumn = this.column;
const start = this.index;
const startingColumn = this.column;
if (this.assertCondition(
isValidCssCharacter(this.peek, this._currentMode),
charStr(this.peek) + ' is not a valid CSS character')) {
return null;
}
var c = this.input.substring(start, start + 1);
const c = this.input.substring(start, start + 1);
this.advance();
return new CssToken(start, startingColumn, this.line, CssTokenType.Character, c);
@ -452,12 +452,12 @@ export class CssScanner {
return null;
}
var start = this.index;
var startingColumn = this.column;
const start = this.index;
const startingColumn = this.column;
this.advance();
if (isIdentifierStart(this.peek, this.peekPeek)) {
var ident = this.scanIdentifier();
var strValue = '@' + ident.strValue;
const ident = this.scanIdentifier();
const strValue = '@' + ident.strValue;
return new CssToken(start, startingColumn, this.line, CssTokenType.AtKeyword, strValue);
} else {
return this.scanCharacter();
@ -473,12 +473,12 @@ export class CssScanner {
}
error(message: string, errorTokenValue: string = null, doNotAdvance: boolean = false): CssToken {
var index: number = this.index;
var column: number = this.column;
var line: number = this.line;
const index: number = this.index;
const column: number = this.column;
const line: number = this.line;
errorTokenValue = errorTokenValue || String.fromCharCode(this.peek);
var invalidToken = new CssToken(index, column, line, CssTokenType.Invalid, errorTokenValue);
var errorMessage =
const invalidToken = new CssToken(index, column, line, CssTokenType.Invalid, errorTokenValue);
const errorMessage =
generateErrorMessage(this.input, message, errorTokenValue, index, line, column);
if (!doNotAdvance) {
this.advance();
@ -501,7 +501,7 @@ function isCommentEnd(code: number, next: number): boolean {
}
function isStringStart(code: number, next: number): boolean {
var target = code;
let target = code;
if (target == chars.$BACKSLASH) {
target = next;
}
@ -509,7 +509,7 @@ function isStringStart(code: number, next: number): boolean {
}
function isIdentifierStart(code: number, next: number): boolean {
var target = code;
let target = code;
if (target == chars.$MINUS) {
target = next;
}

234
modules/@angular/compiler/src/css_parser/css_parser.ts
View File

@ -93,16 +93,16 @@ export class CssParser {
* @param url the name of the CSS file containing the CSS source code
*/
parse(css: string, url: string): ParsedCssResult {
var lexer = new CssLexer();
const lexer = new CssLexer();
this._file = new ParseSourceFile(css, url);
this._scanner = lexer.scan(css, false);
var ast = this._parseStyleSheet(EOF_DELIM_FLAG);
const ast = this._parseStyleSheet(EOF_DELIM_FLAG);
var errors = this._errors;
const errors = this._errors;
this._errors = [];
var result = new ParsedCssResult(errors, ast);
const result = new ParsedCssResult(errors, ast);
this._file = null;
this._scanner = null;
return result;
@ -110,15 +110,15 @@ export class CssParser {
/** @internal */
_parseStyleSheet(delimiters: number): CssStyleSheetAst {
var results: CssRuleAst[] = [];
const results: CssRuleAst[] = [];
this._scanner.consumeEmptyStatements();
while (this._scanner.peek != chars.$EOF) {
this._scanner.setMode(CssLexerMode.BLOCK);
results.push(this._parseRule(delimiters));
}
var span: ParseSourceSpan = null;
let span: ParseSourceSpan = null;
if (results.length > 0) {
var firstRule = results[0];
const firstRule = results[0];
// we collect the last token like so incase there was an
// EOF token that was emitted sometime during the lexing
span = this._generateSourceSpan(firstRule, this._lastToken);
@ -136,11 +136,11 @@ export class CssParser {
/** @internal */
_generateSourceSpan(start: CssToken|CssAst, end: CssToken|CssAst = null): ParseSourceSpan {
var startLoc: ParseLocation;
let startLoc: ParseLocation;
if (start instanceof CssAst) {
startLoc = start.location.start;
} else {
var token = start;
let token = start;
if (!isPresent(token)) {
// the data here is invalid, however, if and when this does
// occur, any other errors associated with this will be collected
@ -153,9 +153,9 @@ export class CssParser {
end = this._lastToken;
}
var endLine: number;
var endColumn: number;
var endIndex: number;
let endLine: number;
let endColumn: number;
let endIndex: number;
if (end instanceof CssAst) {
endLine = end.location.end.line;
endColumn = end.location.end.col;
@ -166,7 +166,7 @@ export class CssParser {
endIndex = end.index;
}
var endLoc = new ParseLocation(this._file, endIndex, endLine, endColumn);
const endLoc = new ParseLocation(this._file, endIndex, endLine, endColumn);
return new ParseSourceSpan(startLoc, endLoc);
}
@ -224,21 +224,21 @@ export class CssParser {
const start = this._getScannerIndex();
this._scanner.setMode(CssLexerMode.BLOCK);
var token = this._scan();
var startToken = token;
const token = this._scan();
const startToken = token;
this._assertCondition(
token.type == CssTokenType.AtKeyword,
`The CSS Rule ${token.strValue} is not a valid [@] rule.`, token);
var block: CssBlockAst;
var type = this._resolveBlockType(token);
var span: ParseSourceSpan;
var tokens: CssToken[];
var endToken: CssToken;
var end: number;
var strValue: string;
var query: CssAtRulePredicateAst;
let block: CssBlockAst;
const type = this._resolveBlockType(token);
let span: ParseSourceSpan;
let tokens: CssToken[];
let endToken: CssToken;
let end: number;
let strValue: string;
let query: CssAtRulePredicateAst;
switch (type) {
case BlockType.Charset:
case BlockType.Namespace:
@ -324,23 +324,23 @@ export class CssParser {
/** @internal */
_parseSelectorRule(delimiters: number): CssRuleAst {
const start = this._getScannerIndex();
var selectors = this._parseSelectors(delimiters);
var block = this._parseStyleBlock(delimiters);
var ruleAst: CssRuleAst;
var span: ParseSourceSpan;
var startSelector = selectors[0];
const selectors = this._parseSelectors(delimiters);
const block = this._parseStyleBlock(delimiters);
let ruleAst: CssRuleAst;
let span: ParseSourceSpan;
const startSelector = selectors[0];
if (isPresent(block)) {
span = this._generateSourceSpan(startSelector, block);
ruleAst = new CssSelectorRuleAst(span, selectors, block);
} else {
var name = this._extractSourceContent(start, this._getScannerIndex() - 1);
var innerTokens: CssToken[] = [];
const name = this._extractSourceContent(start, this._getScannerIndex() - 1);
const innerTokens: CssToken[] = [];
selectors.forEach((selector: CssSelectorAst) => {
selector.selectorParts.forEach((part: CssSimpleSelectorAst) => {
part.tokens.forEach((token: CssToken) => { innerTokens.push(token); });
});
});
var endToken = innerTokens[innerTokens.length - 1];
const endToken = innerTokens[innerTokens.length - 1];
span = this._generateSourceSpan(startSelector, endToken);
ruleAst = new CssUnknownTokenListAst(span, name, innerTokens);
}
@ -353,8 +353,8 @@ export class CssParser {
_parseSelectors(delimiters: number): CssSelectorAst[] {
delimiters |= LBRACE_DELIM_FLAG | SEMICOLON_DELIM_FLAG;
var selectors: CssSelectorAst[] = [];
var isParsingSelectors = true;
const selectors: CssSelectorAst[] = [];
let isParsingSelectors = true;
while (isParsingSelectors) {
selectors.push(this._parseSelector(delimiters));
@ -374,9 +374,9 @@ export class CssParser {
/** @internal */
_scan(): CssToken {
var output = this._scanner.scan();
var token = output.token;
var error = output.error;
const output = this._scanner.scan();
const token = output.token;
const error = output.error;
if (isPresent(error)) {
this._error(error.rawMessage, token);
}
@ -389,9 +389,9 @@ export class CssParser {
/** @internal */
_consume(type: CssTokenType, value: string = null): CssToken {
var output = this._scanner.consume(type, value);
var token = output.token;
var error = output.error;
const output = this._scanner.consume(type, value);
const token = output.token;
const error = output.error;
if (isPresent(error)) {
this._error(error.rawMessage, token);
}
@ -404,23 +404,23 @@ export class CssParser {
delimiters |= RBRACE_DELIM_FLAG;
this._scanner.setMode(CssLexerMode.KEYFRAME_BLOCK);
var startToken = this._consume(CssTokenType.Character, '{');
const startToken = this._consume(CssTokenType.Character, '{');
var definitions: CssKeyframeDefinitionAst[] = [];
const definitions: CssKeyframeDefinitionAst[] = [];
while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
definitions.push(this._parseKeyframeDefinition(delimiters));
}
var endToken = this._consume(CssTokenType.Character, '}');
const endToken = this._consume(CssTokenType.Character, '}');
var span = this._generateSourceSpan(startToken, endToken);
const span = this._generateSourceSpan(startToken, endToken);
return new CssBlockAst(span, definitions);
}
/** @internal */
_parseKeyframeDefinition(delimiters: number): CssKeyframeDefinitionAst {
const start = this._getScannerIndex();
var stepTokens: CssToken[] = [];
const stepTokens: CssToken[] = [];
delimiters |= LBRACE_DELIM_FLAG;
while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
stepTokens.push(this._parseKeyframeLabel(delimiters | COMMA_DELIM_FLAG));
@ -428,9 +428,9 @@ export class CssParser {
this._consume(CssTokenType.Character, ',');
}
}
var stylesBlock = this._parseStyleBlock(delimiters | RBRACE_DELIM_FLAG);
var span = this._generateSourceSpan(stepTokens[0], stylesBlock);
var ast = new CssKeyframeDefinitionAst(span, stepTokens, stylesBlock);
const stylesBlock = this._parseStyleBlock(delimiters | RBRACE_DELIM_FLAG);
const span = this._generateSourceSpan(stepTokens[0], stylesBlock);
const ast = new CssKeyframeDefinitionAst(span, stepTokens, stylesBlock);
this._scanner.setMode(CssLexerMode.BLOCK);
return ast;
@ -449,34 +449,34 @@ export class CssParser {
delimiters &= ~COMMA_DELIM_FLAG;
// we keep the original value since we may use it to recurse when :not, :host are used
var startingDelims = delimiters;
const startingDelims = delimiters;
var startToken = this._consume(CssTokenType.Character, ':');
var tokens = [startToken];
const startToken = this._consume(CssTokenType.Character, ':');
const tokens = [startToken];
if (this._scanner.peek == chars.$COLON) { // ::something
tokens.push(this._consume(CssTokenType.Character, ':'));
}
var innerSelectors: CssSelectorAst[] = [];
const innerSelectors: CssSelectorAst[] = [];
this._scanner.setMode(CssLexerMode.PSEUDO_SELECTOR);
// host, host-context, lang, not, nth-child are all identifiers
var pseudoSelectorToken = this._consume(CssTokenType.Identifier);
var pseudoSelectorName = pseudoSelectorToken.strValue;
const pseudoSelectorToken = this._consume(CssTokenType.Identifier);
const pseudoSelectorName = pseudoSelectorToken.strValue;
tokens.push(pseudoSelectorToken);
// host(), lang(), nth-child(), etc...
if (this._scanner.peek == chars.$LPAREN) {
this._scanner.setMode(CssLexerMode.PSEUDO_SELECTOR_WITH_ARGUMENTS);
var openParenToken = this._consume(CssTokenType.Character, '(');
const openParenToken = this._consume(CssTokenType.Character, '(');
tokens.push(openParenToken);
// :host(innerSelector(s)), :not(selector), etc...
if (_pseudoSelectorSupportsInnerSelectors(pseudoSelectorName)) {
var innerDelims = startingDelims | LPAREN_DELIM_FLAG | RPAREN_DELIM_FLAG;
let innerDelims = startingDelims | LPAREN_DELIM_FLAG | RPAREN_DELIM_FLAG;
if (pseudoSelectorName == 'not') {
// the inner selector inside of :not(...) can only be one
// CSS selector (no commas allowed) ... This is according
@ -491,23 +491,23 @@ export class CssParser {
} else {
// this branch is for things like "en-us, 2k + 1, etc..."
// which all end up in pseudoSelectors like :lang, :nth-child, etc..
var innerValueDelims = delimiters | LBRACE_DELIM_FLAG | COLON_DELIM_FLAG |
const innerValueDelims = delimiters | LBRACE_DELIM_FLAG | COLON_DELIM_FLAG |
RPAREN_DELIM_FLAG | LPAREN_DELIM_FLAG;
while (!characterContainsDelimiter(this._scanner.peek, innerValueDelims)) {
var token = this._scan();
const token = this._scan();
tokens.push(token);
}
}
var closeParenToken = this._consume(CssTokenType.Character, ')');
const closeParenToken = this._consume(CssTokenType.Character, ')');
tokens.push(closeParenToken);
}
const end = this._getScannerIndex() - 1;
var strValue = this._extractSourceContent(start, end);
const strValue = this._extractSourceContent(start, end);
var endToken = tokens[tokens.length - 1];
var span = this._generateSourceSpan(startToken, endToken);
const endToken = tokens[tokens.length - 1];
const span = this._generateSourceSpan(startToken, endToken);
return new CssPseudoSelectorAst(span, strValue, pseudoSelectorName, tokens, innerSelectors);
}
@ -518,21 +518,21 @@ export class CssParser {
delimiters |= COMMA_DELIM_FLAG;
this._scanner.setMode(CssLexerMode.SELECTOR);
var selectorCssTokens: CssToken[] = [];
var pseudoSelectors: CssPseudoSelectorAst[] = [];
const selectorCssTokens: CssToken[] = [];
const pseudoSelectors: CssPseudoSelectorAst[] = [];
var previousToken: CssToken;
let previousToken: CssToken;
var selectorPartDelimiters = delimiters | SPACE_DELIM_FLAG;
var loopOverSelector = !characterContainsDelimiter(this._scanner.peek, selectorPartDelimiters);
const selectorPartDelimiters = delimiters | SPACE_DELIM_FLAG;
let loopOverSelector = !characterContainsDelimiter(this._scanner.peek, selectorPartDelimiters);
var hasAttributeError = false;
let hasAttributeError = false;
while (loopOverSelector) {
var peek = this._scanner.peek;
const peek = this._scanner.peek;
switch (peek) {
case chars.$COLON:
var innerPseudo = this._parsePseudoSelector(delimiters);
let innerPseudo = this._parsePseudoSelector(delimiters);
pseudoSelectors.push(innerPseudo);
this._scanner.setMode(CssLexerMode.SELECTOR);
break;
@ -561,7 +561,7 @@ export class CssParser {
continue;
}
var token = this._scan();
let token = this._scan();
previousToken = token;
selectorCssTokens.push(token);
break;
@ -578,18 +578,18 @@ export class CssParser {
previousToken);
}
var end = this._getScannerIndex() - 1;
let end = this._getScannerIndex() - 1;
// this happens if the selector is not directly followed by
// a comma or curly brace without a space in between
let operator: CssToken = null;
let operatorScanCount = 0;
let lastOperatorToken: CssToken = null;
if (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
var operator: CssToken = null;
var operatorScanCount = 0;
var lastOperatorToken: CssToken = null;
while (operator == null && !characterContainsDelimiter(this._scanner.peek, delimiters) &&
isSelectorOperatorCharacter(this._scanner.peek)) {
var token = this._scan();
var tokenOperator = token.strValue;
let token = this._scan();
const tokenOperator = token.strValue;
operatorScanCount++;
lastOperatorToken = token;
if (tokenOperator != SPACE_OPERATOR) {
@ -607,7 +607,7 @@ export class CssParser {
lastOperatorToken.index, lastOperatorToken.column, lastOperatorToken.line,
CssTokenType.Identifier, DEEP_OPERATOR_STR);
} else {
let text = SLASH_CHARACTER + deepToken.strValue + deepSlash.strValue;
const text = SLASH_CHARACTER + deepToken.strValue + deepSlash.strValue;
this._error(
generateErrorMessage(
this._getSourceContent(), `${text} is an invalid CSS operator`, text, index,
@ -643,7 +643,7 @@ export class CssParser {
this._scanner.consumeWhitespace();
var strValue = this._extractSourceContent(start, end);
const strValue = this._extractSourceContent(start, end);
// if we do come across one or more spaces inside of
// the operators loop then an empty space is still a
@ -654,8 +654,8 @@ export class CssParser {
// please note that `endToken` is reassigned multiple times below
// so please do not optimize the if statements into if/elseif
var startTokenOrAst: CssToken|CssAst = null;
var endTokenOrAst: CssToken|CssAst = null;
let startTokenOrAst: CssToken|CssAst = null;
let endTokenOrAst: CssToken|CssAst = null;
if (selectorCssTokens.length > 0) {
startTokenOrAst = startTokenOrAst || selectorCssTokens[0];
endTokenOrAst = selectorCssTokens[selectorCssTokens.length - 1];
@ -669,7 +669,7 @@ export class CssParser {
endTokenOrAst = operator;
}
var span = this._generateSourceSpan(startTokenOrAst, endTokenOrAst);
const span = this._generateSourceSpan(startTokenOrAst, endTokenOrAst);
return new CssSimpleSelectorAst(span, selectorCssTokens, strValue, pseudoSelectors, operator);
}
@ -678,15 +678,15 @@ export class CssParser {
delimiters |= COMMA_DELIM_FLAG;
this._scanner.setMode(CssLexerMode.SELECTOR);
var simpleSelectors: CssSimpleSelectorAst[] = [];
const simpleSelectors: CssSimpleSelectorAst[] = [];
while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
simpleSelectors.push(this._parseSimpleSelector(delimiters));
this._scanner.consumeWhitespace();
}
var firstSelector = simpleSelectors[0];
var lastSelector = simpleSelectors[simpleSelectors.length - 1];
var span = this._generateSourceSpan(firstSelector, lastSelector);
const firstSelector = simpleSelectors[0];
const lastSelector = simpleSelectors[simpleSelectors.length - 1];
const span = this._generateSourceSpan(firstSelector, lastSelector);
return new CssSelectorAst(span, simpleSelectors);
}
@ -697,11 +697,11 @@ export class CssParser {
this._scanner.setMode(CssLexerMode.STYLE_VALUE);
const start = this._getScannerIndex();
var tokens: CssToken[] = [];
var wsStr = '';
var previous: CssToken;
const tokens: CssToken[] = [];
let wsStr = '';
let previous: CssToken;
while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
var token: CssToken;
let token: CssToken;
if (isPresent(previous) && previous.type == CssTokenType.Identifier &&
this._scanner.peek == chars.$LPAREN) {
token = this._consume(CssTokenType.Character, '(');
@ -731,7 +731,7 @@ export class CssParser {
const end = this._getScannerIndex() - 1;
this._scanner.consumeWhitespace();
var code = this._scanner.peek;
const code = this._scanner.peek;
if (code == chars.$SEMICOLON) {
this._consume(CssTokenType.Character, ';');
} else if (code != chars.$RBRACE) {
@ -742,18 +742,18 @@ export class CssParser {
previous);
}
var strValue = this._extractSourceContent(start, end);
var startToken = tokens[0];
var endToken = tokens[tokens.length - 1];
var span = this._generateSourceSpan(startToken, endToken);
const strValue = this._extractSourceContent(start, end);
const startToken = tokens[0];
const endToken = tokens[tokens.length - 1];
const span = this._generateSourceSpan(startToken, endToken);
return new CssStyleValueAst(span, tokens, strValue);
}
/** @internal */
_collectUntilDelim(delimiters: number, assertType: CssTokenType = null): CssToken[] {
var tokens: CssToken[] = [];
const tokens: CssToken[] = [];
while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
var val = isPresent(assertType) ? this._consume(assertType) : this._scan();
const val = isPresent(assertType) ? this._consume(assertType) : this._scan();
tokens.push(val);
}
return tokens;
@ -765,20 +765,20 @@ export class CssParser {
this._scanner.setMode(CssLexerMode.BLOCK);
var startToken = this._consume(CssTokenType.Character, '{');
const startToken = this._consume(CssTokenType.Character, '{');
this._scanner.consumeEmptyStatements();
var results: CssRuleAst[] = [];
const results: CssRuleAst[] = [];
while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
results.push(this._parseRule(delimiters));
}
var endToken = this._consume(CssTokenType.Character, '}');
const endToken = this._consume(CssTokenType.Character, '}');
this._scanner.setMode(CssLexerMode.BLOCK);
this._scanner.consumeEmptyStatements();
var span = this._generateSourceSpan(startToken, endToken);
const span = this._generateSourceSpan(startToken, endToken);
return new CssBlockAst(span, results);
}
@ -788,12 +788,12 @@ export class CssParser {
this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
var startToken = this._consume(CssTokenType.Character, '{');
const startToken = this._consume(CssTokenType.Character, '{');
if (startToken.numValue != chars.$LBRACE) {
return null;
}
var definitions: CssDefinitionAst[] = [];
const definitions: CssDefinitionAst[] = [];
this._scanner.consumeEmptyStatements();
while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
@ -801,12 +801,12 @@ export class CssParser {
this._scanner.consumeEmptyStatements();
}
var endToken = this._consume(CssTokenType.Character, '}');
const endToken = this._consume(CssTokenType.Character, '}');
this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
this._scanner.consumeEmptyStatements();
var span = this._generateSourceSpan(startToken, endToken);
const span = this._generateSourceSpan(startToken, endToken);
return new CssStylesBlockAst(span, definitions);
}
@ -814,10 +814,10 @@ export class CssParser {
_parseDefinition(delimiters: number): CssDefinitionAst {
this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
var prop = this._consume(CssTokenType.Identifier);
var parseValue: boolean = false;
var value: CssStyleValueAst = null;
var endToken: CssToken|CssStyleValueAst = prop;
let prop = this._consume(CssTokenType.Identifier);
let parseValue: boolean = false;
let value: CssStyleValueAst = null;
let endToken: CssToken|CssStyleValueAst = prop;
// the colon value separates the prop from the style.
// there are a few cases as to what could happen if it
@ -830,13 +830,13 @@ export class CssParser {
break;
default:
var propStr = [prop.strValue];
let propStr = [prop.strValue];
if (this._scanner.peek != chars.$COLON) {
// this will throw the error
var nextValue = this._consume(CssTokenType.Character, ':');
const nextValue = this._consume(CssTokenType.Character, ':');
propStr.push(nextValue.strValue);
var remainingTokens = this._collectUntilDelim(
const remainingTokens = this._collectUntilDelim(
delimiters | COLON_DELIM_FLAG | SEMICOLON_DELIM_FLAG, CssTokenType.Identifier);
if (remainingTokens.length > 0) {
remainingTokens.forEach((token) => { propStr.push(token.strValue); });
@ -865,7 +865,7 @@ export class CssParser {
prop);
}
var span = this._generateSourceSpan(prop, endToken);
const span = this._generateSourceSpan(prop, endToken);
return new CssDefinitionAst(span, prop, value);
}
@ -880,8 +880,8 @@ export class CssParser {
/** @internal */
_error(message: string, problemToken: CssToken) {
var length = problemToken.strValue.length;
var error = CssParseError.create(
const length = problemToken.strValue.length;
const error = CssParseError.create(
this._file, 0, problemToken.line, problemToken.column, length, message);
this._errors.push(error);
}
@ -891,9 +891,9 @@ export class CssParseError extends ParseError {
static create(
file: ParseSourceFile, offset: number, line: number, col: number, length: number,
errMsg: string): CssParseError {
var start = new ParseLocation(file, offset, line, col);
var end = new ParseLocation(file, offset, line, col + length);
var span = new ParseSourceSpan(start, end);
const start = new ParseLocation(file, offset, line, col);
const end = new ParseLocation(file, offset, line, col + length);
const span = new ParseSourceSpan(start, end);
return new CssParseError(span, 'CSS Parse Error: ' + errMsg);
}