source: trip-planner-front/node_modules/@angular/compiler/src/expression_parser/lexer.js

Last change on this file was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 55.6 KB
RevLine 
[6a3a178]1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8(function (factory) {
9 if (typeof module === "object" && typeof module.exports === "object") {
10 var v = factory(require, exports);
11 if (v !== undefined) module.exports = v;
12 }
13 else if (typeof define === "function" && define.amd) {
14 define("@angular/compiler/src/expression_parser/lexer", ["require", "exports", "@angular/compiler/src/chars"], factory);
15 }
16})(function (require, exports) {
17 "use strict";
18 Object.defineProperty(exports, "__esModule", { value: true });
19 exports.isIdentifier = exports.EOF = exports.Token = exports.Lexer = exports.TokenType = void 0;
20 var chars = require("@angular/compiler/src/chars");
21 var TokenType;
22 (function (TokenType) {
23 TokenType[TokenType["Character"] = 0] = "Character";
24 TokenType[TokenType["Identifier"] = 1] = "Identifier";
25 TokenType[TokenType["PrivateIdentifier"] = 2] = "PrivateIdentifier";
26 TokenType[TokenType["Keyword"] = 3] = "Keyword";
27 TokenType[TokenType["String"] = 4] = "String";
28 TokenType[TokenType["Operator"] = 5] = "Operator";
29 TokenType[TokenType["Number"] = 6] = "Number";
30 TokenType[TokenType["Error"] = 7] = "Error";
31 })(TokenType = exports.TokenType || (exports.TokenType = {}));
32 var KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
33 var Lexer = /** @class */ (function () {
34 function Lexer() {
35 }
36 Lexer.prototype.tokenize = function (text) {
37 var scanner = new _Scanner(text);
38 var tokens = [];
39 var token = scanner.scanToken();
40 while (token != null) {
41 tokens.push(token);
42 token = scanner.scanToken();
43 }
44 return tokens;
45 };
46 return Lexer;
47 }());
48 exports.Lexer = Lexer;
49 var Token = /** @class */ (function () {
50 function Token(index, end, type, numValue, strValue) {
51 this.index = index;
52 this.end = end;
53 this.type = type;
54 this.numValue = numValue;
55 this.strValue = strValue;
56 }
57 Token.prototype.isCharacter = function (code) {
58 return this.type == TokenType.Character && this.numValue == code;
59 };
60 Token.prototype.isNumber = function () {
61 return this.type == TokenType.Number;
62 };
63 Token.prototype.isString = function () {
64 return this.type == TokenType.String;
65 };
66 Token.prototype.isOperator = function (operator) {
67 return this.type == TokenType.Operator && this.strValue == operator;
68 };
69 Token.prototype.isIdentifier = function () {
70 return this.type == TokenType.Identifier;
71 };
72 Token.prototype.isPrivateIdentifier = function () {
73 return this.type == TokenType.PrivateIdentifier;
74 };
75 Token.prototype.isKeyword = function () {
76 return this.type == TokenType.Keyword;
77 };
78 Token.prototype.isKeywordLet = function () {
79 return this.type == TokenType.Keyword && this.strValue == 'let';
80 };
81 Token.prototype.isKeywordAs = function () {
82 return this.type == TokenType.Keyword && this.strValue == 'as';
83 };
84 Token.prototype.isKeywordNull = function () {
85 return this.type == TokenType.Keyword && this.strValue == 'null';
86 };
87 Token.prototype.isKeywordUndefined = function () {
88 return this.type == TokenType.Keyword && this.strValue == 'undefined';
89 };
90 Token.prototype.isKeywordTrue = function () {
91 return this.type == TokenType.Keyword && this.strValue == 'true';
92 };
93 Token.prototype.isKeywordFalse = function () {
94 return this.type == TokenType.Keyword && this.strValue == 'false';
95 };
96 Token.prototype.isKeywordThis = function () {
97 return this.type == TokenType.Keyword && this.strValue == 'this';
98 };
99 Token.prototype.isError = function () {
100 return this.type == TokenType.Error;
101 };
102 Token.prototype.toNumber = function () {
103 return this.type == TokenType.Number ? this.numValue : -1;
104 };
105 Token.prototype.toString = function () {
106 switch (this.type) {
107 case TokenType.Character:
108 case TokenType.Identifier:
109 case TokenType.Keyword:
110 case TokenType.Operator:
111 case TokenType.PrivateIdentifier:
112 case TokenType.String:
113 case TokenType.Error:
114 return this.strValue;
115 case TokenType.Number:
116 return this.numValue.toString();
117 default:
118 return null;
119 }
120 };
121 return Token;
122 }());
123 exports.Token = Token;
124 function newCharacterToken(index, end, code) {
125 return new Token(index, end, TokenType.Character, code, String.fromCharCode(code));
126 }
127 function newIdentifierToken(index, end, text) {
128 return new Token(index, end, TokenType.Identifier, 0, text);
129 }
130 function newPrivateIdentifierToken(index, end, text) {
131 return new Token(index, end, TokenType.PrivateIdentifier, 0, text);
132 }
133 function newKeywordToken(index, end, text) {
134 return new Token(index, end, TokenType.Keyword, 0, text);
135 }
136 function newOperatorToken(index, end, text) {
137 return new Token(index, end, TokenType.Operator, 0, text);
138 }
139 function newStringToken(index, end, text) {
140 return new Token(index, end, TokenType.String, 0, text);
141 }
142 function newNumberToken(index, end, n) {
143 return new Token(index, end, TokenType.Number, n, '');
144 }
145 function newErrorToken(index, end, message) {
146 return new Token(index, end, TokenType.Error, 0, message);
147 }
148 exports.EOF = new Token(-1, -1, TokenType.Character, 0, '');
149 var _Scanner = /** @class */ (function () {
150 function _Scanner(input) {
151 this.input = input;
152 this.peek = 0;
153 this.index = -1;
154 this.length = input.length;
155 this.advance();
156 }
157 _Scanner.prototype.advance = function () {
158 this.peek = ++this.index >= this.length ? chars.$EOF : this.input.charCodeAt(this.index);
159 };
160 _Scanner.prototype.scanToken = function () {
161 var input = this.input, length = this.length;
162 var peek = this.peek, index = this.index;
163 // Skip whitespace.
164 while (peek <= chars.$SPACE) {
165 if (++index >= length) {
166 peek = chars.$EOF;
167 break;
168 }
169 else {
170 peek = input.charCodeAt(index);
171 }
172 }
173 this.peek = peek;
174 this.index = index;
175 if (index >= length) {
176 return null;
177 }
178 // Handle identifiers and numbers.
179 if (isIdentifierStart(peek))
180 return this.scanIdentifier();
181 if (chars.isDigit(peek))
182 return this.scanNumber(index);
183 var start = index;
184 switch (peek) {
185 case chars.$PERIOD:
186 this.advance();
187 return chars.isDigit(this.peek) ? this.scanNumber(start) :
188 newCharacterToken(start, this.index, chars.$PERIOD);
189 case chars.$LPAREN:
190 case chars.$RPAREN:
191 case chars.$LBRACE:
192 case chars.$RBRACE:
193 case chars.$LBRACKET:
194 case chars.$RBRACKET:
195 case chars.$COMMA:
196 case chars.$COLON:
197 case chars.$SEMICOLON:
198 return this.scanCharacter(start, peek);
199 case chars.$SQ:
200 case chars.$DQ:
201 return this.scanString();
202 case chars.$HASH:
203 return this.scanPrivateIdentifier();
204 case chars.$PLUS:
205 case chars.$MINUS:
206 case chars.$STAR:
207 case chars.$SLASH:
208 case chars.$PERCENT:
209 case chars.$CARET:
210 return this.scanOperator(start, String.fromCharCode(peek));
211 case chars.$QUESTION:
212 return this.scanQuestion(start);
213 case chars.$LT:
214 case chars.$GT:
215 return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=');
216 case chars.$BANG:
217 case chars.$EQ:
218 return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=', chars.$EQ, '=');
219 case chars.$AMPERSAND:
220 return this.scanComplexOperator(start, '&', chars.$AMPERSAND, '&');
221 case chars.$BAR:
222 return this.scanComplexOperator(start, '|', chars.$BAR, '|');
223 case chars.$NBSP:
224 while (chars.isWhitespace(this.peek))
225 this.advance();
226 return this.scanToken();
227 }
228 this.advance();
229 return this.error("Unexpected character [" + String.fromCharCode(peek) + "]", 0);
230 };
231 _Scanner.prototype.scanCharacter = function (start, code) {
232 this.advance();
233 return newCharacterToken(start, this.index, code);
234 };
235 _Scanner.prototype.scanOperator = function (start, str) {
236 this.advance();
237 return newOperatorToken(start, this.index, str);
238 };
239 /**
240 * Tokenize a 2/3 char long operator
241 *
242 * @param start start index in the expression
243 * @param one first symbol (always part of the operator)
244 * @param twoCode code point for the second symbol
245 * @param two second symbol (part of the operator when the second code point matches)
246 * @param threeCode code point for the third symbol
247 * @param three third symbol (part of the operator when provided and matches source expression)
248 */
249 _Scanner.prototype.scanComplexOperator = function (start, one, twoCode, two, threeCode, three) {
250 this.advance();
251 var str = one;
252 if (this.peek == twoCode) {
253 this.advance();
254 str += two;
255 }
256 if (threeCode != null && this.peek == threeCode) {
257 this.advance();
258 str += three;
259 }
260 return newOperatorToken(start, this.index, str);
261 };
262 _Scanner.prototype.scanIdentifier = function () {
263 var start = this.index;
264 this.advance();
265 while (isIdentifierPart(this.peek))
266 this.advance();
267 var str = this.input.substring(start, this.index);
268 return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, this.index, str) :
269 newIdentifierToken(start, this.index, str);
270 };
271 /** Scans an ECMAScript private identifier. */
272 _Scanner.prototype.scanPrivateIdentifier = function () {
273 var start = this.index;
274 this.advance();
275 if (!isIdentifierStart(this.peek)) {
276 return this.error('Invalid character [#]', -1);
277 }
278 while (isIdentifierPart(this.peek))
279 this.advance();
280 var identifierName = this.input.substring(start, this.index);
281 return newPrivateIdentifierToken(start, this.index, identifierName);
282 };
283 _Scanner.prototype.scanNumber = function (start) {
284 var simple = (this.index === start);
285 var hasSeparators = false;
286 this.advance(); // Skip initial digit.
287 while (true) {
288 if (chars.isDigit(this.peek)) {
289 // Do nothing.
290 }
291 else if (this.peek === chars.$_) {
292 // Separators are only valid when they're surrounded by digits. E.g. `1_0_1` is
293 // valid while `_101` and `101_` are not. The separator can't be next to the decimal
294 // point or another separator either. Note that it's unlikely that we'll hit a case where
295 // the underscore is at the start, because that's a valid identifier and it will be picked
296 // up earlier in the parsing. We validate for it anyway just in case.
297 if (!chars.isDigit(this.input.charCodeAt(this.index - 1)) ||
298 !chars.isDigit(this.input.charCodeAt(this.index + 1))) {
299 return this.error('Invalid numeric separator', 0);
300 }
301 hasSeparators = true;
302 }
303 else if (this.peek === chars.$PERIOD) {
304 simple = false;
305 }
306 else if (isExponentStart(this.peek)) {
307 this.advance();
308 if (isExponentSign(this.peek))
309 this.advance();
310 if (!chars.isDigit(this.peek))
311 return this.error('Invalid exponent', -1);
312 simple = false;
313 }
314 else {
315 break;
316 }
317 this.advance();
318 }
319 var str = this.input.substring(start, this.index);
320 if (hasSeparators) {
321 str = str.replace(/_/g, '');
322 }
323 var value = simple ? parseIntAutoRadix(str) : parseFloat(str);
324 return newNumberToken(start, this.index, value);
325 };
326 _Scanner.prototype.scanString = function () {
327 var start = this.index;
328 var quote = this.peek;
329 this.advance(); // Skip initial quote.
330 var buffer = '';
331 var marker = this.index;
332 var input = this.input;
333 while (this.peek != quote) {
334 if (this.peek == chars.$BACKSLASH) {
335 buffer += input.substring(marker, this.index);
336 this.advance();
337 var unescapedCode = void 0;
338 // Workaround for TS2.1-introduced type strictness
339 this.peek = this.peek;
340 if (this.peek == chars.$u) {
341 // 4 character hex code for unicode character.
342 var hex = input.substring(this.index + 1, this.index + 5);
343 if (/^[0-9a-f]+$/i.test(hex)) {
344 unescapedCode = parseInt(hex, 16);
345 }
346 else {
347 return this.error("Invalid unicode escape [\\u" + hex + "]", 0);
348 }
349 for (var i = 0; i < 5; i++) {
350 this.advance();
351 }
352 }
353 else {
354 unescapedCode = unescape(this.peek);
355 this.advance();
356 }
357 buffer += String.fromCharCode(unescapedCode);
358 marker = this.index;
359 }
360 else if (this.peek == chars.$EOF) {
361 return this.error('Unterminated quote', 0);
362 }
363 else {
364 this.advance();
365 }
366 }
367 var last = input.substring(marker, this.index);
368 this.advance(); // Skip terminating quote.
369 return newStringToken(start, this.index, buffer + last);
370 };
371 _Scanner.prototype.scanQuestion = function (start) {
372 this.advance();
373 var str = '?';
374 // Either `a ?? b` or 'a?.b'.
375 if (this.peek === chars.$QUESTION || this.peek === chars.$PERIOD) {
376 str += this.peek === chars.$PERIOD ? '.' : '?';
377 this.advance();
378 }
379 return newOperatorToken(start, this.index, str);
380 };
381 _Scanner.prototype.error = function (message, offset) {
382 var position = this.index + offset;
383 return newErrorToken(position, this.index, "Lexer Error: " + message + " at column " + position + " in expression [" + this.input + "]");
384 };
385 return _Scanner;
386 }());
387 function isIdentifierStart(code) {
388 return (chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||
389 (code == chars.$_) || (code == chars.$$);
390 }
391 function isIdentifier(input) {
392 if (input.length == 0)
393 return false;
394 var scanner = new _Scanner(input);
395 if (!isIdentifierStart(scanner.peek))
396 return false;
397 scanner.advance();
398 while (scanner.peek !== chars.$EOF) {
399 if (!isIdentifierPart(scanner.peek))
400 return false;
401 scanner.advance();
402 }
403 return true;
404 }
405 exports.isIdentifier = isIdentifier;
406 function isIdentifierPart(code) {
407 return chars.isAsciiLetter(code) || chars.isDigit(code) || (code == chars.$_) ||
408 (code == chars.$$);
409 }
410 function isExponentStart(code) {
411 return code == chars.$e || code == chars.$E;
412 }
413 function isExponentSign(code) {
414 return code == chars.$MINUS || code == chars.$PLUS;
415 }
416 function unescape(code) {
417 switch (code) {
418 case chars.$n:
419 return chars.$LF;
420 case chars.$f:
421 return chars.$FF;
422 case chars.$r:
423 return chars.$CR;
424 case chars.$t:
425 return chars.$TAB;
426 case chars.$v:
427 return chars.$VTAB;
428 default:
429 return code;
430 }
431 }
432 function parseIntAutoRadix(text) {
433 var result = parseInt(text);
434 if (isNaN(result)) {
435 throw new Error('Invalid integer literal when parsing ' + text);
436 }
437 return result;
438 }
439});
440//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/expression_parser/lexer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as chars from '../chars';\n\nexport enum TokenType {\n  Character,\n  Identifier,\n  PrivateIdentifier,\n  Keyword,\n  String,\n  Operator,\n  Number,\n  Error\n}\n\nconst KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];\n\nexport class Lexer {\n  tokenize(text: string): Token[] {\n    const scanner = new _Scanner(text);\n    const tokens: Token[] = [];\n    let token = scanner.scanToken();\n    while (token != null) {\n      tokens.push(token);\n      token = scanner.scanToken();\n    }\n    return tokens;\n  }\n}\n\nexport class Token {\n  constructor(\n      public index: number, public end: number, public type: TokenType, public numValue: number,\n      public strValue: string) {}\n\n  isCharacter(code: number): boolean {\n    return this.type == TokenType.Character && this.numValue == code;\n  }\n\n  isNumber(): boolean {\n    return this.type == TokenType.Number;\n  }\n\n  isString(): boolean {\n    return this.type == TokenType.String;\n  }\n\n  isOperator(operator: string): boolean {\n    return this.type == TokenType.Operator && this.strValue == operator;\n  }\n\n  isIdentifier(): boolean {\n    return this.type == TokenType.Identifier;\n  }\n\n  isPrivateIdentifier(): boolean {\n    return this.type == TokenType.PrivateIdentifier;\n  }\n\n  isKeyword(): boolean {\n    return this.type == TokenType.Keyword;\n  }\n\n  isKeywordLet(): boolean {\n    return this.type == TokenType.Keyword && this.strValue == 'let';\n  }\n\n  isKeywordAs(): boolean {\n    return this.type == TokenType.Keyword && this.strValue == 'as';\n  }\n\n  isKeywordNull(): boolean {\n    return this.type == TokenType.Keyword && this.strValue == 'null';\n  }\n\n  isKeywordUndefined(): boolean {\n    return this.type == TokenType.Keyword && this.strValue == 'undefined';\n  }\n\n  isKeywordTrue(): boolean {\n    return this.type == TokenType.Keyword && this.strValue == 'true';\n  }\n\n  isKeywordFalse(): boolean {\n    return this.type == TokenType.Keyword && this.strValue == 'false';\n  }\n\n  isKeywordThis(): boolean {\n    return this.type == TokenType.Keyword && this.strValue == 'this';\n  }\n\n  isError(): boolean {\n    return this.type == TokenType.Error;\n  }\n\n  toNumber(): number {\n    return this.type == TokenType.Number ? this.numValue : -1;\n  }\n\n  toString(): string|null {\n    switch (this.type) {\n      case TokenType.Character:\n      case TokenType.Identifier:\n      case TokenType.Keyword:\n      case TokenType.Operator:\n      case TokenType.PrivateIdentifier:\n      case TokenType.String:\n      case TokenType.Error:\n        return this.strValue;\n      case TokenType.Number:\n        return this.numValue.toString();\n      default:\n        return null;\n    }\n  }\n}\n\nfunction newCharacterToken(index: number, end: number, code: number): Token {\n  return new Token(index, end, TokenType.Character, code, String.fromCharCode(code));\n}\n\nfunction newIdentifierToken(index: number, end: number, text: string): Token {\n  return new Token(index, end, TokenType.Identifier, 0, text);\n}\n\nfunction newPrivateIdentifierToken(index: number, end: number, text: string): Token {\n  return new Token(index, end, TokenType.PrivateIdentifier, 0, text);\n}\n\nfunction newKeywordToken(index: number, end: number, text: string): Token {\n  return new Token(index, end, TokenType.Keyword, 0, text);\n}\n\nfunction newOperatorToken(index: number, end: number, text: string): Token {\n  return new Token(index, end, TokenType.Operator, 0, text);\n}\n\nfunction newStringToken(index: number, end: number, text: string): Token {\n  return new Token(index, end, TokenType.String, 0, text);\n}\n\nfunction newNumberToken(index: number, end: number, n: number): Token {\n  return new Token(index, end, TokenType.Number, n, '');\n}\n\nfunction newErrorToken(index: number, end: number, message: string): Token {\n  return new Token(index, end, TokenType.Error, 0, message);\n}\n\nexport const EOF: Token = new Token(-1, -1, TokenType.Character, 0, '');\n\nclass _Scanner {\n  length: number;\n  peek: number = 0;\n  index: number = -1;\n\n  constructor(public input: string) {\n    this.length = input.length;\n    this.advance();\n  }\n\n  advance() {\n    this.peek = ++this.index >= this.length ? chars.$EOF : this.input.charCodeAt(this.index);\n  }\n\n  scanToken(): Token|null {\n    const input = this.input, length = this.length;\n    let peek = this.peek, index = this.index;\n\n    // Skip whitespace.\n    while (peek <= chars.$SPACE) {\n      if (++index >= length) {\n        peek = chars.$EOF;\n        break;\n      } else {\n        peek = input.charCodeAt(index);\n      }\n    }\n\n    this.peek = peek;\n    this.index = index;\n\n    if (index >= length) {\n      return null;\n    }\n\n    // Handle identifiers and numbers.\n    if (isIdentifierStart(peek)) return this.scanIdentifier();\n    if (chars.isDigit(peek)) return this.scanNumber(index);\n\n    const start: number = index;\n    switch (peek) {\n      case chars.$PERIOD:\n        this.advance();\n        return chars.isDigit(this.peek) ? this.scanNumber(start) :\n                                          newCharacterToken(start, this.index, chars.$PERIOD);\n      case chars.$LPAREN:\n      case chars.$RPAREN:\n      case chars.$LBRACE:\n      case chars.$RBRACE:\n      case chars.$LBRACKET:\n      case chars.$RBRACKET:\n      case chars.$COMMA:\n      case chars.$COLON:\n      case chars.$SEMICOLON:\n        return this.scanCharacter(start, peek);\n      case chars.$SQ:\n      case chars.$DQ:\n        return this.scanString();\n      case chars.$HASH:\n        return this.scanPrivateIdentifier();\n      case chars.$PLUS:\n      case chars.$MINUS:\n      case chars.$STAR:\n      case chars.$SLASH:\n      case chars.$PERCENT:\n      case chars.$CARET:\n        return this.scanOperator(start, String.fromCharCode(peek));\n      case chars.$QUESTION:\n        return this.scanQuestion(start);\n      case chars.$LT:\n      case chars.$GT:\n        return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=');\n      case chars.$BANG:\n      case chars.$EQ:\n        return this.scanComplexOperator(\n            start, String.fromCharCode(peek), chars.$EQ, '=', chars.$EQ, '=');\n      case chars.$AMPERSAND:\n        return this.scanComplexOperator(start, '&', chars.$AMPERSAND, '&');\n      case chars.$BAR:\n        return this.scanComplexOperator(start, '|', chars.$BAR, '|');\n      case chars.$NBSP:\n        while (chars.isWhitespace(this.peek)) this.advance();\n        return this.scanToken();\n    }\n\n    this.advance();\n    return this.error(`Unexpected character [${String.fromCharCode(peek)}]`, 0);\n  }\n\n  scanCharacter(start: number, code: number): Token {\n    this.advance();\n    return newCharacterToken(start, this.index, code);\n  }\n\n\n  scanOperator(start: number, str: string): Token {\n    this.advance();\n    return newOperatorToken(start, this.index, str);\n  }\n\n  /**\n   * Tokenize a 2/3 char long operator\n   *\n   * @param start start index in the expression\n   * @param one first symbol (always part of the operator)\n   * @param twoCode code point for the second symbol\n   * @param two second symbol (part of the operator when the second code point matches)\n   * @param threeCode code point for the third symbol\n   * @param three third symbol (part of the operator when provided and matches source expression)\n   */\n  scanComplexOperator(\n      start: number, one: string, twoCode: number, two: string, threeCode?: number,\n      three?: string): Token {\n    this.advance();\n    let str: string = one;\n    if (this.peek == twoCode) {\n      this.advance();\n      str += two;\n    }\n    if (threeCode != null && this.peek == threeCode) {\n      this.advance();\n      str += three;\n    }\n    return newOperatorToken(start, this.index, str);\n  }\n\n  scanIdentifier(): Token {\n    const start: number = this.index;\n    this.advance();\n    while (isIdentifierPart(this.peek)) this.advance();\n    const str: string = this.input.substring(start, this.index);\n    return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, this.index, str) :\n                                        newIdentifierToken(start, this.index, str);\n  }\n\n  /** Scans an ECMAScript private identifier. */\n  scanPrivateIdentifier(): Token {\n    const start: number = this.index;\n    this.advance();\n    if (!isIdentifierStart(this.peek)) {\n      return this.error('Invalid character [#]', -1);\n    }\n    while (isIdentifierPart(this.peek)) this.advance();\n    const identifierName: string = this.input.substring(start, this.index);\n    return newPrivateIdentifierToken(start, this.index, identifierName);\n  }\n\n  scanNumber(start: number): Token {\n    let simple = (this.index === start);\n    let hasSeparators = false;\n    this.advance();  // Skip initial digit.\n    while (true) {\n      if (chars.isDigit(this.peek)) {\n        // Do nothing.\n      } else if (this.peek === chars.$_) {\n        // Separators are only valid when they're surrounded by digits. E.g. `1_0_1` is\n        // valid while `_101` and `101_` are not. The separator can't be next to the decimal\n        // point or another separator either. Note that it's unlikely that we'll hit a case where\n        // the underscore is at the start, because that's a valid identifier and it will be picked\n        // up earlier in the parsing. We validate for it anyway just in case.\n        if (!chars.isDigit(this.input.charCodeAt(this.index - 1)) ||\n            !chars.isDigit(this.input.charCodeAt(this.index + 1))) {\n          return this.error('Invalid numeric separator', 0);\n        }\n        hasSeparators = true;\n      } else if (this.peek === chars.$PERIOD) {\n        simple = false;\n      } else if (isExponentStart(this.peek)) {\n        this.advance();\n        if (isExponentSign(this.peek)) this.advance();\n        if (!chars.isDigit(this.peek)) return this.error('Invalid exponent', -1);\n        simple = false;\n      } else {\n        break;\n      }\n      this.advance();\n    }\n\n    let str = this.input.substring(start, this.index);\n    if (hasSeparators) {\n      str = str.replace(/_/g, '');\n    }\n    const value = simple ? parseIntAutoRadix(str) : parseFloat(str);\n    return newNumberToken(start, this.index, value);\n  }\n\n  scanString(): Token {\n    const start: number = this.index;\n    const quote: number = this.peek;\n    this.advance();  // Skip initial quote.\n\n    let buffer: string = '';\n    let marker: number = this.index;\n    const input: string = this.input;\n\n    while (this.peek != quote) {\n      if (this.peek == chars.$BACKSLASH) {\n        buffer += input.substring(marker, this.index);\n        this.advance();\n        let unescapedCode: number;\n        // Workaround for TS2.1-introduced type strictness\n        this.peek = this.peek;\n        if (this.peek == chars.$u) {\n          // 4 character hex code for unicode character.\n          const hex: string = input.substring(this.index + 1, this.index + 5);\n          if (/^[0-9a-f]+$/i.test(hex)) {\n            unescapedCode = parseInt(hex, 16);\n          } else {\n            return this.error(`Invalid unicode escape [\\\\u${hex}]`, 0);\n          }\n          for (let i: number = 0; i < 5; i++) {\n            this.advance();\n          }\n        } else {\n          unescapedCode = unescape(this.peek);\n          this.advance();\n        }\n        buffer += String.fromCharCode(unescapedCode);\n        marker = this.index;\n      } else if (this.peek == chars.$EOF) {\n        return this.error('Unterminated quote', 0);\n      } else {\n        this.advance();\n      }\n    }\n\n    const last: string = input.substring(marker, this.index);\n    this.advance();  // Skip terminating quote.\n\n    return newStringToken(start, this.index, buffer + last);\n  }\n\n  scanQuestion(start: number): Token {\n    this.advance();\n    let str: string = '?';\n    // Either `a ?? b` or 'a?.b'.\n    if (this.peek === chars.$QUESTION || this.peek === chars.$PERIOD) {\n      str += this.peek === chars.$PERIOD ? '.' : '?';\n      this.advance();\n    }\n    return newOperatorToken(start, this.index, str);\n  }\n\n  error(message: string, offset: number): Token {\n    const position: number = this.index + offset;\n    return newErrorToken(\n        position, this.index,\n        `Lexer Error: ${message} at column ${position} in expression [${this.input}]`);\n  }\n}\n\nfunction isIdentifierStart(code: number): boolean {\n  return (chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||\n      (code == chars.$_) || (code == chars.$$);\n}\n\nexport function isIdentifier(input: string): boolean {\n  if (input.length == 0) return false;\n  const scanner = new _Scanner(input);\n  if (!isIdentifierStart(scanner.peek)) return false;\n  scanner.advance();\n  while (scanner.peek !== chars.$EOF) {\n    if (!isIdentifierPart(scanner.peek)) return false;\n    scanner.advance();\n  }\n  return true;\n}\n\nfunction isIdentifierPart(code: number): boolean {\n  return chars.isAsciiLetter(code) || chars.isDigit(code) || (code == chars.$_) ||\n      (code == chars.$$);\n}\n\nfunction isExponentStart(code: number): boolean {\n  return code == chars.$e || code == chars.$E;\n}\n\nfunction isExponentSign(code: number): boolean {\n  return code == chars.$MINUS || code == chars.$PLUS;\n}\n\nfunction unescape(code: number): number {\n  switch (code) {\n    case chars.$n:\n      return chars.$LF;\n    case chars.$f:\n      return chars.$FF;\n    case chars.$r:\n      return chars.$CR;\n    case chars.$t:\n      return chars.$TAB;\n    case chars.$v:\n      return chars.$VTAB;\n    default:\n      return code;\n  }\n}\n\nfunction parseIntAutoRadix(text: string): number {\n  const result: number = parseInt(text);\n  if (isNaN(result)) {\n    throw new Error('Invalid integer literal when parsing ' + text);\n  }\n  return result;\n}\n"]}
Note: See TracBrowser for help on using the repository browser.