@auscope/angular2parse 20.3.0 → 22.0.0

package/projects/angular2parse/src/lib/angular/compiler/lexer.ts

@@ -0,0 +1,383 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as chars from './chars';
+import {NumberWrapper} from '../facade/lang';
+
+export enum TokenType {
+    Character,
+    Identifier,
+    Keyword,
+    String,
+    Operator,
+    Number,
+    Error
+}
+
+const KEYWORDS = ['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
+
+export class Lexer {
+    tokenize(text: string): Token[] {
+        const scanner = new _Scanner(text);
+        const tokens: Token[] = [];
+        let token = scanner.scanToken();
+        while (token != null) {
+            tokens.push(token);
+            token = scanner.scanToken();
+        }
+        return tokens;
+    }
+}
+
+export class Token {
+    constructor(
+        public index: number, public type: TokenType, public numValue: number,
+        public strValue: string) {}
+
+    isCharacter(code: number): boolean {
+        return this.type == TokenType.Character && this.numValue == code;
+    }
+
+    isNumber(): boolean { return this.type == TokenType.Number; }
+
+    isString(): boolean { return this.type == TokenType.String; }
+
+    isOperator(operater: string): boolean {
+        return this.type == TokenType.Operator && this.strValue == operater;
+    }
+
+    isIdentifier(): boolean { return this.type == TokenType.Identifier; }
+
+    isKeyword(): boolean { return this.type == TokenType.Keyword; }
+
+    isKeywordLet(): boolean { return this.type == TokenType.Keyword && this.strValue == 'let'; }
+
+    isKeywordNull(): boolean { return this.type == TokenType.Keyword && this.strValue == 'null'; }
+
+    isKeywordUndefined(): boolean {
+        return this.type == TokenType.Keyword && this.strValue == 'undefined';
+    }
+
+    isKeywordTrue(): boolean { return this.type == TokenType.Keyword && this.strValue == 'true'; }
+
+    isKeywordFalse(): boolean { return this.type == TokenType.Keyword && this.strValue == 'false'; }
+
+    isKeywordThis(): boolean { return this.type == TokenType.Keyword && this.strValue == 'this'; }
+
+    isError(): boolean { return this.type == TokenType.Error; }
+
+    toNumber(): number { return this.type == TokenType.Number ? this.numValue : -1; }
+
+    toString(): string | null {
+        switch (this.type) {
+            case TokenType.Character:
+            case TokenType.Identifier:
+            case TokenType.Keyword:
+            case TokenType.Operator:
+            case TokenType.String:
+            case TokenType.Error:
+                return this.strValue;
+            case TokenType.Number:
+                return this.numValue.toString();
+            default:
+                return null;
+        }
+    }
+}
+
+function newCharacterToken(index: number, code: number): Token {
+    return new Token(index, TokenType.Character, code, String.fromCharCode(code));
+}
+
+function newIdentifierToken(index: number, text: string): Token {
+    return new Token(index, TokenType.Identifier, 0, text);
+}
+
+function newKeywordToken(index: number, text: string): Token {
+    return new Token(index, TokenType.Keyword, 0, text);
+}
+
+function newOperatorToken(index: number, text: string): Token {
+    return new Token(index, TokenType.Operator, 0, text);
+}
+
+function newStringToken(index: number, text: string): Token {
+    return new Token(index, TokenType.String, 0, text);
+}
+
+function newNumberToken(index: number, n: number): Token {
+    return new Token(index, TokenType.Number, n, '');
+}
+
+function newErrorToken(index: number, message: string): Token {
+    return new Token(index, TokenType.Error, 0, message);
+}
+
+export const EOF: Token = new Token(-1, TokenType.Character, 0, '');
+
+class _Scanner {
+    length: number;
+    peek: number = 0;
+    index: number = -1;
+
+    constructor(public input: string) {
+        this.length = input.length;
+        this.advance();
+    }
+
+    advance() {
+        this.peek = ++this.index >= this.length ? chars.$EOF : this.input.charCodeAt(this.index);
+    }
+
+    scanToken(): Token | null {
+        const input = this.input, length = this.length;
+        let peek = this.peek, index = this.index;
+
+        // Skip whitespace.
+        while (peek <= chars.$SPACE) {
+            if (++index >= length) {
+                peek = chars.$EOF;
+                break;
+            } else {
+                peek = input.charCodeAt(index);
+            }
+        }
+
+        this.peek = peek;
+        this.index = index;
+
+        if (index >= length) {
+            return null;
+        }
+
+        // Handle identifiers and numbers.
+        if (isIdentifierStart(peek)) return this.scanIdentifier();
+        if (chars.isDigit(peek)) return this.scanNumber(index);
+
+        const start: number = index;
+        switch (peek) {
+            case chars.$PERIOD:
+                this.advance();
+                return chars.isDigit(this.peek) ? this.scanNumber(start) :
+                    newCharacterToken(start, chars.$PERIOD);
+            case chars.$LPAREN:
+            case chars.$RPAREN:
+            case chars.$LBRACE:
+            case chars.$RBRACE:
+            case chars.$LBRACKET:
+            case chars.$RBRACKET:
+            case chars.$COMMA:
+            case chars.$COLON:
+            case chars.$SEMICOLON:
+                return this.scanCharacter(start, peek);
+            case chars.$SQ:
+            case chars.$DQ:
+                return this.scanString();
+            case chars.$HASH:
+            case chars.$PLUS:
+            case chars.$MINUS:
+            case chars.$STAR:
+            case chars.$SLASH:
+            case chars.$PERCENT:
+            case chars.$CARET:
+                return this.scanOperator(start, String.fromCharCode(peek));
+            case chars.$QUESTION:
+                return this.scanComplexOperator(start, '?', chars.$PERIOD, '.');
+            case chars.$LT:
+            case chars.$GT:
+                return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=');
+            case chars.$BANG:
+            case chars.$EQ:
+                return this.scanComplexOperator(
+                    start, String.fromCharCode(peek), chars.$EQ, '=', chars.$EQ, '=');
+            case chars.$AMPERSAND:
+                return this.scanComplexOperator(start, '&', chars.$AMPERSAND, '&');
+            case chars.$BAR:
+                return this.scanComplexOperator(start, '|', chars.$BAR, '|');
+            case chars.$NBSP:
+                while (chars.isWhitespace(this.peek)) this.advance();
+                return this.scanToken();
+        }
+
+        this.advance();
+        return this.error(`Unexpected character [${String.fromCharCode(peek)}]`, 0);
+    }
+
+    scanCharacter(start: number, code: number): Token {
+        this.advance();
+        return newCharacterToken(start, code);
+    }
+
+
+    scanOperator(start: number, str: string): Token {
+        this.advance();
+        return newOperatorToken(start, str);
+    }
+
+    /**
+     * Tokenize a 2/3 char long operator
+     *
+     * @param start start index in the expression
+     * @param one first symbol (always part of the operator)
+     * @param twoCode code point for the second symbol
+     * @param two second symbol (part of the operator when the second code point matches)
+     * @param threeCode code point for the third symbol
+     * @param three third symbol (part of the operator when provided and matches source expression)
+     * @returns {Token}
+     */
+    scanComplexOperator(
+        start: number, one: string, twoCode: number, two: string, threeCode?: number,
+        three?: string): Token {
+        this.advance();
+        let str: string = one;
+        if (this.peek == twoCode) {
+            this.advance();
+            str += two;
+        }
+        if (threeCode != null && this.peek == threeCode) {
+            this.advance();
+            str += three;
+        }
+        return newOperatorToken(start, str);
+    }
+
+    scanIdentifier(): Token {
+        const start: number = this.index;
+        this.advance();
+        while (isIdentifierPart(this.peek)) this.advance();
+        const str: string = this.input.substring(start, this.index);
+        return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, str) :
+            newIdentifierToken(start, str);
+    }
+
+    scanNumber(start: number): Token {
+        let simple: boolean = (this.index === start);
+        this.advance();  // Skip initial digit.
+        while (true) {
+            if (chars.isDigit(this.peek)) {
+                // Do nothing.
+            } else if (this.peek == chars.$PERIOD) {
+                simple = false;
+            } else if (isExponentStart(this.peek)) {
+                this.advance();
+                if (isExponentSign(this.peek)) this.advance();
+                if (!chars.isDigit(this.peek)) return this.error('Invalid exponent', -1);
+                simple = false;
+            } else {
+                break;
+            }
+            this.advance();
+        }
+        const str: string = this.input.substring(start, this.index);
+        const value: number = simple ? NumberWrapper.parseIntAutoRadix(str) : parseFloat(str);
+        return newNumberToken(start, value);
+    }
+
+    scanString(): Token {
+        const start: number = this.index;
+        const quote: number = this.peek;
+        this.advance();  // Skip initial quote.
+
+        let buffer: string = '';
+        let marker: number = this.index;
+        const input: string = this.input;
+
+        while (this.peek != quote) {
+            if (this.peek == chars.$BACKSLASH) {
+                buffer += input.substring(marker, this.index);
+                this.advance();
+                let unescapedCode: number;
+                // Workaround for TS2.1-introduced type strictness
+                this.peek = this.peek;
+                if (this.peek == chars.$u) {
+                    // 4 character hex code for unicode character.
+                    const hex: string = input.substring(this.index + 1, this.index + 5);
+                    if (/^[0-9a-f]+$/i.test(hex)) {
+                        unescapedCode = parseInt(hex, 16);
+                    } else {
+                        return this.error(`Invalid unicode escape [\\u${hex}]`, 0);
+                    }
+                    for (let i: number = 0; i < 5; i++) {
+                        this.advance();
+                    }
+                } else {
+                    unescapedCode = unescape(this.peek);
+                    this.advance();
+                }
+                buffer += String.fromCharCode(unescapedCode);
+                marker = this.index;
+            } else if (this.peek == chars.$EOF) {
+                return this.error('Unterminated quote', 0);
+            } else {
+                this.advance();
+            }
+        }
+
+        const last: string = input.substring(marker, this.index);
+        this.advance();  // Skip terminating quote.
+
+        return newStringToken(start, buffer + last);
+    }
+
+    error(message: string, offset: number): Token {
+        const position: number = this.index + offset;
+        return newErrorToken(
+            position, `Lexer Error: ${message} at column ${position} in expression [${this.input}]`);
+    }
+}
+
+function isIdentifierStart(code: number): boolean {
+    return (chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||
+        (code == chars.$_) || (code == chars.$$);
+}
+
+export function isIdentifier(input: string): boolean {
+    if (input.length == 0) return false;
+    const scanner = new _Scanner(input);
+    if (!isIdentifierStart(scanner.peek)) return false;
+    scanner.advance();
+    while (scanner.peek !== chars.$EOF) {
+        if (!isIdentifierPart(scanner.peek)) return false;
+        scanner.advance();
+    }
+    return true;
+}
+
+function isIdentifierPart(code: number): boolean {
+    return chars.isAsciiLetter(code) || chars.isDigit(code) || (code == chars.$_) ||
+        (code == chars.$$);
+}
+
+function isExponentStart(code: number): boolean {
+    return code == chars.$e || code == chars.$E;
+}
+
+function isExponentSign(code: number): boolean {
+    return code == chars.$MINUS || code == chars.$PLUS;
+}
+
+export function isQuote(code: number): boolean {
+    return code === chars.$SQ || code === chars.$DQ || code === chars.$BT;
+}
+
+function unescape(code: number): number {
+    switch (code) {
+        case chars.$n:
+            return chars.$LF;
+        case chars.$f:
+            return chars.$FF;
+        case chars.$r:
+            return chars.$CR;
+        case chars.$t:
+            return chars.$TAB;
+        case chars.$v:
+            return chars.$VTAB;
+        default:
+            return code;
+    }
+}

package/projects/angular2parse/src/lib/angular/compiler/parser.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InterpolationConfig } from './interpolation-config';
+import { AST, ASTWithSource, BindingPipe, LiteralMap, ParseSpan, ParserError, TemplateBinding } from './ast';
+import { Lexer, Token } from './lexer';
+export declare class SplitInterpolation {
+    strings: string[];
+    expressions: string[];
+    offsets: number[];
+    constructor(strings: string[], expressions: string[], offsets: number[]);
+}
+export declare class TemplateBindingParseResult {
+    templateBindings: TemplateBinding[];
+    warnings: string[];
+    errors: ParserError[];
+    constructor(templateBindings: TemplateBinding[], warnings: string[], errors: ParserError[]);
+}
+export declare class Parser {
+    private _lexer;
+    private errors;
+    constructor(_lexer: Lexer);
+    parseAction(input: string, location: any, interpolationConfig?: InterpolationConfig): ASTWithSource;
+    parseBinding(input: string, location: any, interpolationConfig?: InterpolationConfig): ASTWithSource;
+    parseSimpleBinding(input: string, location: string, interpolationConfig?: InterpolationConfig): ASTWithSource;
+    private _reportError;
+    private _parseBindingAst;
+    private _parseQuote;
+    parseTemplateBindings(prefixToken: string, input: string, location: any): TemplateBindingParseResult;
+    parseInterpolation(input: string, location: any, interpolationConfig?: InterpolationConfig): ASTWithSource;
+    splitInterpolation(input: string, location: string, interpolationConfig?: InterpolationConfig): SplitInterpolation;
+    wrapLiteralPrimitive(input: string, location: any): ASTWithSource;
+    private _stripComments;
+    private _commentStart;
+    private _checkNoInterpolation;
+    private _findInterpolationErrorColumn;
+}
+export declare class _ParseAST {
+    input: string;
+    location: any;
+    tokens: Token[];
+    inputLength: number;
+    parseAction: boolean;
+    private errors;
+    private offset;
+    private rparensExpected;
+    private rbracketsExpected;
+    private rbracesExpected;
+    index: number;
+    constructor(input: string, location: any, tokens: Token[], inputLength: number, parseAction: boolean, errors: ParserError[], offset: number);
+    peek(offset: number): Token;
+    get next(): Token;
+    get inputIndex(): number;
+    span(start: number): ParseSpan;
+    advance(): void;
+    optionalCharacter(code: number): boolean;
+    peekKeywordLet(): boolean;
+    expectCharacter(code: number): void;
+    optionalOperator(op: string): boolean;
+    expectOperator(operator: string): void;
+    expectIdentifierOrKeyword(): string;
+    expectIdentifierOrKeywordOrString(): string;
+    parseChain(): AST;
+    parsePipe(): AST;
+    parseExpression(): AST;
+    parseConditional(): AST;
+    parseLogicalOr(): AST;
+    parseLogicalAnd(): AST;
+    parseEquality(): AST;
+    parseRelational(): AST;
+    parseAdditive(): AST;
+    parseMultiplicative(): AST;
+    parsePrefix(): AST;
+    parseCallChain(): AST;
+    parsePrimary(): AST;
+    parseExpressionList(terminator: number): AST[];
+    parseLiteralMap(): LiteralMap;
+    parseAccessMemberOrMethodCall(receiver: AST, isSafe?: boolean): AST;
+    parseCallArguments(): BindingPipe[];
+    /**
+     * An identifier, a keyword, a string with an optional `-` inbetween.
+     */
+    expectTemplateBindingKey(): string;
+    parseTemplateBindings(): TemplateBindingParseResult;
+    error(message: string, index?: number): void;
+    private locationText;
+    private skip;
+}
+//# sourceMappingURL=parser.d.ts.map

package/projects/angular2parse/src/lib/angular/compiler/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["parser.ts"],"names":[],"mappings":"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"}