immosquare-cleaner 0.1.34 → 0.1.35

data/node_modules/eslint-plugin-import/node_modules/doctrine/lib/typed.js

@@ -1,1305 +0,0 @@
-/*
- * @fileoverview Type expression parser.
- * @author Yusuke Suzuki <utatane.tea@gmail.com>
- * @author Dan Tao <daniel.tao@gmail.com>
- * @author Andrew Eisenberg <andrew@eisenberg.as>
- */
-
-// "typed", the Type Expression Parser for doctrine.
-
-(function () {
-    'use strict';
-
-    var Syntax,
-        Token,
-        source,
-        length,
-        index,
-        previous,
-        token,
-        value,
-        esutils,
-        utility,
-        rangeOffset,
-        addRange;
-
-    esutils = require('esutils');
-    utility = require('./utility');
-
-    Syntax = {
-        NullableLiteral: 'NullableLiteral',
-        AllLiteral: 'AllLiteral',
-        NullLiteral: 'NullLiteral',
-        UndefinedLiteral: 'UndefinedLiteral',
-        VoidLiteral: 'VoidLiteral',
-        UnionType: 'UnionType',
-        ArrayType: 'ArrayType',
-        RecordType: 'RecordType',
-        FieldType: 'FieldType',
-        FunctionType: 'FunctionType',
-        ParameterType: 'ParameterType',
-        RestType: 'RestType',
-        NonNullableType: 'NonNullableType',
-        OptionalType: 'OptionalType',
-        NullableType: 'NullableType',
-        NameExpression: 'NameExpression',
-        TypeApplication: 'TypeApplication',
-        StringLiteralType: 'StringLiteralType',
-        NumericLiteralType: 'NumericLiteralType',
-        BooleanLiteralType: 'BooleanLiteralType'
-    };
-
-    Token = {
-        ILLEGAL: 0,    // ILLEGAL
-        DOT_LT: 1,     // .<
-        REST: 2,       // ...
-        LT: 3,         // <
-        GT: 4,         // >
-        LPAREN: 5,     // (
-        RPAREN: 6,     // )
-        LBRACE: 7,     // {
-        RBRACE: 8,     // }
-        LBRACK: 9,    // [
-        RBRACK: 10,    // ]
-        COMMA: 11,     // ,
-        COLON: 12,     // :
-        STAR: 13,      // *
-        PIPE: 14,      // |
-        QUESTION: 15,  // ?
-        BANG: 16,      // !
-        EQUAL: 17,     // =
-        NAME: 18,      // name token
-        STRING: 19,    // string
-        NUMBER: 20,    // number
-        EOF: 21
-    };
-
-    function isTypeName(ch) {
-        return '><(){}[],:*|?!='.indexOf(String.fromCharCode(ch)) === -1 && !esutils.code.isWhiteSpace(ch) && !esutils.code.isLineTerminator(ch);
-    }
-
-    function Context(previous, index, token, value) {
-        this._previous = previous;
-        this._index = index;
-        this._token = token;
-        this._value = value;
-    }
-
-    Context.prototype.restore = function () {
-        previous = this._previous;
-        index = this._index;
-        token = this._token;
-        value = this._value;
-    };
-
-    Context.save = function () {
-        return new Context(previous, index, token, value);
-    };
-
-    function maybeAddRange(node, range) {
-        if (addRange) {
-            node.range = [range[0] + rangeOffset, range[1] + rangeOffset];
-        }
-        return node;
-    }
-
-    function advance() {
-        var ch = source.charAt(index);
-        index += 1;
-        return ch;
-    }
-
-    function scanHexEscape(prefix) {
-        var i, len, ch, code = 0;
-
-        len = (prefix === 'u') ? 4 : 2;
-        for (i = 0; i < len; ++i) {
-            if (index < length && esutils.code.isHexDigit(source.charCodeAt(index))) {
-                ch = advance();
-                code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
-            } else {
-                return '';
-            }
-        }
-        return String.fromCharCode(code);
-    }
-
-    function scanString() {
-        var str = '', quote, ch, code, unescaped, restore; //TODO review removal octal = false
-        quote = source.charAt(index);
-        ++index;
-
-        while (index < length) {
-            ch = advance();
-
-            if (ch === quote) {
-                quote = '';
-                break;
-            } else if (ch === '\\') {
-                ch = advance();
-                if (!esutils.code.isLineTerminator(ch.charCodeAt(0))) {
-                    switch (ch) {
-                    case 'n':
-                        str += '\n';
-                        break;
-                    case 'r':
-                        str += '\r';
-                        break;
-                    case 't':
-                        str += '\t';
-                        break;
-                    case 'u':
-                    case 'x':
-                        restore = index;
-                        unescaped = scanHexEscape(ch);
-                        if (unescaped) {
-                            str += unescaped;
-                        } else {
-                            index = restore;
-                            str += ch;
-                        }
-                        break;
-                    case 'b':
-                        str += '\b';
-                        break;
-                    case 'f':
-                        str += '\f';
-                        break;
-                    case 'v':
-                        str += '\v';
-                        break;
-
-                    default:
-                        if (esutils.code.isOctalDigit(ch.charCodeAt(0))) {
-                            code = '01234567'.indexOf(ch);
-
-                            // \0 is not octal escape sequence
-                            // Deprecating unused code. TODO review removal
-                            //if (code !== 0) {
-                            //    octal = true;
-                            //}
-
-                            if (index < length && esutils.code.isOctalDigit(source.charCodeAt(index))) {
-                                //TODO Review Removal octal = true;
-                                code = code * 8 + '01234567'.indexOf(advance());
-
-                                // 3 digits are only allowed when string starts
-                                // with 0, 1, 2, 3
-                                if ('0123'.indexOf(ch) >= 0 &&
-                                        index < length &&
-                                        esutils.code.isOctalDigit(source.charCodeAt(index))) {
-                                    code = code * 8 + '01234567'.indexOf(advance());
-                                }
-                            }
-                            str += String.fromCharCode(code);
-                        } else {
-                            str += ch;
-                        }
-                        break;
-                    }
-                } else {
-                    if (ch ===  '\r' && source.charCodeAt(index) === 0x0A  /* '\n' */) {
-                        ++index;
-                    }
-                }
-            } else if (esutils.code.isLineTerminator(ch.charCodeAt(0))) {
-                break;
-            } else {
-                str += ch;
-            }
-        }
-
-        if (quote !== '') {
-            utility.throwError('unexpected quote');
-        }
-
-        value = str;
-        return Token.STRING;
-    }
-
-    function scanNumber() {
-        var number, ch;
-
-        number = '';
-        ch = source.charCodeAt(index);
-
-        if (ch !== 0x2E  /* '.' */) {
-            number = advance();
-            ch = source.charCodeAt(index);
-
-            if (number === '0') {
-                if (ch === 0x78  /* 'x' */ || ch === 0x58  /* 'X' */) {
-                    number += advance();
-                    while (index < length) {
-                        ch = source.charCodeAt(index);
-                        if (!esutils.code.isHexDigit(ch)) {
-                            break;
-                        }
-                        number += advance();
-                    }
-
-                    if (number.length <= 2) {
-                        // only 0x
-                        utility.throwError('unexpected token');
-                    }
-
-                    if (index < length) {
-                        ch = source.charCodeAt(index);
-                        if (esutils.code.isIdentifierStartES5(ch)) {
-                            utility.throwError('unexpected token');
-                        }
-                    }
-                    value = parseInt(number, 16);
-                    return Token.NUMBER;
-                }
-
-                if (esutils.code.isOctalDigit(ch)) {
-                    number += advance();
-                    while (index < length) {
-                        ch = source.charCodeAt(index);
-                        if (!esutils.code.isOctalDigit(ch)) {
-                            break;
-                        }
-                        number += advance();
-                    }
-
-                    if (index < length) {
-                        ch = source.charCodeAt(index);
-                        if (esutils.code.isIdentifierStartES5(ch) || esutils.code.isDecimalDigit(ch)) {
-                            utility.throwError('unexpected token');
-                        }
-                    }
-                    value = parseInt(number, 8);
-                    return Token.NUMBER;
-                }
-
-                if (esutils.code.isDecimalDigit(ch)) {
-                    utility.throwError('unexpected token');
-                }
-            }
-
-            while (index < length) {
-                ch = source.charCodeAt(index);
-                if (!esutils.code.isDecimalDigit(ch)) {
-                    break;
-                }
-                number += advance();
-            }
-        }
-
-        if (ch === 0x2E  /* '.' */) {
-            number += advance();
-            while (index < length) {
-                ch = source.charCodeAt(index);
-                if (!esutils.code.isDecimalDigit(ch)) {
-                    break;
-                }
-                number += advance();
-            }
-        }
-
-        if (ch === 0x65  /* 'e' */ || ch === 0x45  /* 'E' */) {
-            number += advance();
-
-            ch = source.charCodeAt(index);
-            if (ch === 0x2B  /* '+' */ || ch === 0x2D  /* '-' */) {
-                number += advance();
-            }
-
-            ch = source.charCodeAt(index);
-            if (esutils.code.isDecimalDigit(ch)) {
-                number += advance();
-                while (index < length) {
-                    ch = source.charCodeAt(index);
-                    if (!esutils.code.isDecimalDigit(ch)) {
-                        break;
-                    }
-                    number += advance();
-                }
-            } else {
-                utility.throwError('unexpected token');
-            }
-        }
-
-        if (index < length) {
-            ch = source.charCodeAt(index);
-            if (esutils.code.isIdentifierStartES5(ch)) {
-                utility.throwError('unexpected token');
-            }
-        }
-
-        value = parseFloat(number);
-        return Token.NUMBER;
-    }
-
-
-    function scanTypeName() {
-        var ch, ch2;
-
-        value = advance();
-        while (index < length && isTypeName(source.charCodeAt(index))) {
-            ch = source.charCodeAt(index);
-            if (ch === 0x2E  /* '.' */) {
-                if ((index + 1) >= length) {
-                    return Token.ILLEGAL;
-                }
-                ch2 = source.charCodeAt(index + 1);
-                if (ch2 === 0x3C  /* '<' */) {
-                    break;
-                }
-            }
-            value += advance();
-        }
-        return Token.NAME;
-    }
-
-    function next() {
-        var ch;
-
-        previous = index;
-
-        while (index < length && esutils.code.isWhiteSpace(source.charCodeAt(index))) {
-            advance();
-        }
-        if (index >= length) {
-            token = Token.EOF;
-            return token;
-        }
-
-        ch = source.charCodeAt(index);
-        switch (ch) {
-        case 0x27:  /* ''' */
-        case 0x22:  /* '"' */
-            token = scanString();
-            return token;
-
-        case 0x3A:  /* ':' */
-            advance();
-            token = Token.COLON;
-            return token;
-
-        case 0x2C:  /* ',' */
-            advance();
-            token = Token.COMMA;
-            return token;
-
-        case 0x28:  /* '(' */
-            advance();
-            token = Token.LPAREN;
-            return token;
-
-        case 0x29:  /* ')' */
-            advance();
-            token = Token.RPAREN;
-            return token;
-
-        case 0x5B:  /* '[' */
-            advance();
-            token = Token.LBRACK;
-            return token;
-
-        case 0x5D:  /* ']' */
-            advance();
-            token = Token.RBRACK;
-            return token;
-
-        case 0x7B:  /* '{' */
-            advance();
-            token = Token.LBRACE;
-            return token;
-
-        case 0x7D:  /* '}' */
-            advance();
-            token = Token.RBRACE;
-            return token;
-
-        case 0x2E:  /* '.' */
-            if (index + 1 < length) {
-                ch = source.charCodeAt(index + 1);
-                if (ch === 0x3C  /* '<' */) {
-                    advance();  // '.'
-                    advance();  // '<'
-                    token = Token.DOT_LT;
-                    return token;
-                }
-
-                if (ch === 0x2E  /* '.' */ && index + 2 < length && source.charCodeAt(index + 2) === 0x2E  /* '.' */) {
-                    advance();  // '.'
-                    advance();  // '.'
-                    advance();  // '.'
-                    token = Token.REST;
-                    return token;
-                }
-
-                if (esutils.code.isDecimalDigit(ch)) {
-                    token = scanNumber();
-                    return token;
-                }
-            }
-            token = Token.ILLEGAL;
-            return token;
-
-        case 0x3C:  /* '<' */
-            advance();
-            token = Token.LT;
-            return token;
-
-        case 0x3E:  /* '>' */
-            advance();
-            token = Token.GT;
-            return token;
-
-        case 0x2A:  /* '*' */
-            advance();
-            token = Token.STAR;
-            return token;
-
-        case 0x7C:  /* '|' */
-            advance();
-            token = Token.PIPE;
-            return token;
-
-        case 0x3F:  /* '?' */
-            advance();
-            token = Token.QUESTION;
-            return token;
-
-        case 0x21:  /* '!' */
-            advance();
-            token = Token.BANG;
-            return token;
-
-        case 0x3D:  /* '=' */
-            advance();
-            token = Token.EQUAL;
-            return token;
-
-        case 0x2D: /* '-' */
-            token = scanNumber();
-            return token;
-
-        default:
-            if (esutils.code.isDecimalDigit(ch)) {
-                token = scanNumber();
-                return token;
-            }
-
-            // type string permits following case,
-            //
-            // namespace.module.MyClass
-            //
-            // this reduced 1 token TK_NAME
-            utility.assert(isTypeName(ch));
-            token = scanTypeName();
-            return token;
-        }
-    }
-
-    function consume(target, text) {
-        utility.assert(token === target, text || 'consumed token not matched');
-        next();
-    }
-
-    function expect(target, message) {
-        if (token !== target) {
-            utility.throwError(message || 'unexpected token');
-        }
-        next();
-    }
-
-    // UnionType := '(' TypeUnionList ')'
-    //
-    // TypeUnionList :=
-    //     <<empty>>
-    //   | NonemptyTypeUnionList
-    //
-    // NonemptyTypeUnionList :=
-    //     TypeExpression
-    //   | TypeExpression '|' NonemptyTypeUnionList
-    function parseUnionType() {
-        var elements, startIndex = index - 1;
-        consume(Token.LPAREN, 'UnionType should start with (');
-        elements = [];
-        if (token !== Token.RPAREN) {
-            while (true) {
-                elements.push(parseTypeExpression());
-                if (token === Token.RPAREN) {
-                    break;
-                }
-                expect(Token.PIPE);
-            }
-        }
-        consume(Token.RPAREN, 'UnionType should end with )');
-        return maybeAddRange({
-            type: Syntax.UnionType,
-            elements: elements
-        }, [startIndex, previous]);
-    }
-
-    // ArrayType := '[' ElementTypeList ']'
-    //
-    // ElementTypeList :=
-    //     <<empty>>
-    //  | TypeExpression
-    //  | '...' TypeExpression
-    //  | TypeExpression ',' ElementTypeList
-    function parseArrayType() {
-        var elements, startIndex = index - 1, restStartIndex;
-        consume(Token.LBRACK, 'ArrayType should start with [');
-        elements = [];
-        while (token !== Token.RBRACK) {
-            if (token === Token.REST) {
-                restStartIndex = index - 3;
-                consume(Token.REST);
-                elements.push(maybeAddRange({
-                    type: Syntax.RestType,
-                    expression: parseTypeExpression()
-                }, [restStartIndex, previous]));
-                break;
-            } else {
-                elements.push(parseTypeExpression());
-            }
-            if (token !== Token.RBRACK) {
-                expect(Token.COMMA);
-            }
-        }
-        expect(Token.RBRACK);
-        return maybeAddRange({
-            type: Syntax.ArrayType,
-            elements: elements
-        }, [startIndex, previous]);
-    }
-
-    function parseFieldName() {
-        var v = value;
-        if (token === Token.NAME || token === Token.STRING) {
-            next();
-            return v;
-        }
-
-        if (token === Token.NUMBER) {
-            consume(Token.NUMBER);
-            return String(v);
-        }
-
-        utility.throwError('unexpected token');
-    }
-
-    // FieldType :=
-    //     FieldName
-    //   | FieldName ':' TypeExpression
-    //
-    // FieldName :=
-    //     NameExpression
-    //   | StringLiteral
-    //   | NumberLiteral
-    //   | ReservedIdentifier
-    function parseFieldType() {
-        var key, rangeStart = previous;
-
-        key = parseFieldName();
-        if (token === Token.COLON) {
-            consume(Token.COLON);
-            return maybeAddRange({
-                type: Syntax.FieldType,
-                key: key,
-                value: parseTypeExpression()
-            }, [rangeStart, previous]);
-        }
-        return maybeAddRange({
-            type: Syntax.FieldType,
-            key: key,
-            value: null
-        }, [rangeStart, previous]);
-    }
-
-    // RecordType := '{' FieldTypeList '}'
-    //
-    // FieldTypeList :=
-    //     <<empty>>
-    //   | FieldType
-    //   | FieldType ',' FieldTypeList
-    function parseRecordType() {
-        var fields, rangeStart = index - 1, rangeEnd;
-
-        consume(Token.LBRACE, 'RecordType should start with {');
-        fields = [];
-        if (token === Token.COMMA) {
-            consume(Token.COMMA);
-        } else {
-            while (token !== Token.RBRACE) {
-                fields.push(parseFieldType());
-                if (token !== Token.RBRACE) {
-                    expect(Token.COMMA);
-                }
-            }
-        }
-        rangeEnd = index;
-        expect(Token.RBRACE);
-        return maybeAddRange({
-            type: Syntax.RecordType,
-            fields: fields
-        }, [rangeStart, rangeEnd]);
-    }
-
-    // NameExpression :=
-    //    Identifier
-    //  | TagIdentifier ':' Identifier
-    //
-    // Tag identifier is one of "module", "external" or "event"
-    // Identifier is the same as Token.NAME, including any dots, something like
-    // namespace.module.MyClass
-    function parseNameExpression() {
-        var name = value, rangeStart = index - name.length;
-        expect(Token.NAME);
-
-        if (token === Token.COLON && (
-                name === 'module' ||
-                name === 'external' ||
-                name === 'event')) {
-            consume(Token.COLON);
-            name += ':' + value;
-            expect(Token.NAME);
-        }
-
-        return maybeAddRange({
-            type: Syntax.NameExpression,
-            name: name
-        }, [rangeStart, previous]);
-    }
-
-    // TypeExpressionList :=
-    //     TopLevelTypeExpression
-    //   | TopLevelTypeExpression ',' TypeExpressionList
-    function parseTypeExpressionList() {
-        var elements = [];
-
-        elements.push(parseTop());
-        while (token === Token.COMMA) {
-            consume(Token.COMMA);
-            elements.push(parseTop());
-        }
-        return elements;
-    }
-
-    // TypeName :=
-    //     NameExpression
-    //   | NameExpression TypeApplication
-    //
-    // TypeApplication :=
-    //     '.<' TypeExpressionList '>'
-    //   | '<' TypeExpressionList '>'   // this is extension of doctrine
-    function parseTypeName() {
-        var expr, applications, startIndex = index - value.length;
-
-        expr = parseNameExpression();
-        if (token === Token.DOT_LT || token === Token.LT) {
-            next();
-            applications = parseTypeExpressionList();
-            expect(Token.GT);
-            return maybeAddRange({
-                type: Syntax.TypeApplication,
-                expression: expr,
-                applications: applications
-            }, [startIndex, previous]);
-        }
-        return expr;
-    }
-
-    // ResultType :=
-    //     <<empty>>
-    //   | ':' void
-    //   | ':' TypeExpression
-    //
-    // BNF is above
-    // but, we remove <<empty>> pattern, so token is always TypeToken::COLON
-    function parseResultType() {
-        consume(Token.COLON, 'ResultType should start with :');
-        if (token === Token.NAME && value === 'void') {
-            consume(Token.NAME);
-            return {
-                type: Syntax.VoidLiteral
-            };
-        }
-        return parseTypeExpression();
-    }
-
-    // ParametersType :=
-    //     RestParameterType
-    //   | NonRestParametersType
-    //   | NonRestParametersType ',' RestParameterType
-    //
-    // RestParameterType :=
-    //     '...'
-    //     '...' Identifier
-    //
-    // NonRestParametersType :=
-    //     ParameterType ',' NonRestParametersType
-    //   | ParameterType
-    //   | OptionalParametersType
-    //
-    // OptionalParametersType :=
-    //     OptionalParameterType
-    //   | OptionalParameterType, OptionalParametersType
-    //
-    // OptionalParameterType := ParameterType=
-    //
-    // ParameterType := TypeExpression | Identifier ':' TypeExpression
-    //
-    // Identifier is "new" or "this"
-    function parseParametersType() {
-        var params = [], optionalSequence = false, expr, rest = false, startIndex, restStartIndex = index - 3, nameStartIndex;
-
-        while (token !== Token.RPAREN) {
-            if (token === Token.REST) {
-                // RestParameterType
-                consume(Token.REST);
-                rest = true;
-            }
-
-            startIndex = previous;
-
-            expr = parseTypeExpression();
-            if (expr.type === Syntax.NameExpression && token === Token.COLON) {
-                nameStartIndex = previous - expr.name.length;
-                // Identifier ':' TypeExpression
-                consume(Token.COLON);
-                expr = maybeAddRange({
-                    type: Syntax.ParameterType,
-                    name: expr.name,
-                    expression: parseTypeExpression()
-                }, [nameStartIndex, previous]);
-            }
-            if (token === Token.EQUAL) {
-                consume(Token.EQUAL);
-                expr = maybeAddRange({
-                    type: Syntax.OptionalType,
-                    expression: expr
-                }, [startIndex, previous]);
-                optionalSequence = true;
-            } else {
-                if (optionalSequence) {
-                    utility.throwError('unexpected token');
-                }
-            }
-            if (rest) {
-                expr = maybeAddRange({
-                    type: Syntax.RestType,
-                    expression: expr
-                }, [restStartIndex, previous]);
-            }
-            params.push(expr);
-            if (token !== Token.RPAREN) {
-                expect(Token.COMMA);
-            }
-        }
-        return params;
-    }
-
-    // FunctionType := 'function' FunctionSignatureType
-    //
-    // FunctionSignatureType :=
-    //   | TypeParameters '(' ')' ResultType
-    //   | TypeParameters '(' ParametersType ')' ResultType
-    //   | TypeParameters '(' 'this' ':' TypeName ')' ResultType
-    //   | TypeParameters '(' 'this' ':' TypeName ',' ParametersType ')' ResultType
-    function parseFunctionType() {
-        var isNew, thisBinding, params, result, fnType, startIndex = index - value.length;
-        utility.assert(token === Token.NAME && value === 'function', 'FunctionType should start with \'function\'');
-        consume(Token.NAME);
-
-        // Google Closure Compiler is not implementing TypeParameters.
-        // So we do not. if we don't get '(', we see it as error.
-        expect(Token.LPAREN);
-
-        isNew = false;
-        params = [];
-        thisBinding = null;
-        if (token !== Token.RPAREN) {
-            // ParametersType or 'this'
-            if (token === Token.NAME &&
-                    (value === 'this' || value === 'new')) {
-                // 'this' or 'new'
-                // 'new' is Closure Compiler extension
-                isNew = value === 'new';
-                consume(Token.NAME);
-                expect(Token.COLON);
-                thisBinding = parseTypeName();
-                if (token === Token.COMMA) {
-                    consume(Token.COMMA);
-                    params = parseParametersType();
-                }
-            } else {
-                params = parseParametersType();
-            }
-        }
-
-        expect(Token.RPAREN);
-
-        result = null;
-        if (token === Token.COLON) {
-            result = parseResultType();
-        }
-
-        fnType = maybeAddRange({
-            type: Syntax.FunctionType,
-            params: params,
-            result: result
-        }, [startIndex, previous]);
-        if (thisBinding) {
-            // avoid adding null 'new' and 'this' properties
-            fnType['this'] = thisBinding;
-            if (isNew) {
-                fnType['new'] = true;
-            }
-        }
-        return fnType;
-    }
-
-    // BasicTypeExpression :=
-    //     '*'
-    //   | 'null'
-    //   | 'undefined'
-    //   | TypeName
-    //   | FunctionType
-    //   | UnionType
-    //   | RecordType
-    //   | ArrayType
-    function parseBasicTypeExpression() {
-        var context, startIndex;
-        switch (token) {
-        case Token.STAR:
-            consume(Token.STAR);
-            return maybeAddRange({
-                type: Syntax.AllLiteral
-            }, [previous - 1, previous]);
-
-        case Token.LPAREN:
-            return parseUnionType();
-
-        case Token.LBRACK:
-            return parseArrayType();
-
-        case Token.LBRACE:
-            return parseRecordType();
-
-        case Token.NAME:
-            startIndex = index - value.length;
-
-            if (value === 'null') {
-                consume(Token.NAME);
-                return maybeAddRange({
-                    type: Syntax.NullLiteral
-                }, [startIndex, previous]);
-            }
-
-            if (value === 'undefined') {
-                consume(Token.NAME);
-                return maybeAddRange({
-                    type: Syntax.UndefinedLiteral
-                }, [startIndex, previous]);
-            }
-
-            if (value === 'true' || value === 'false') {
-                consume(Token.NAME);
-                return maybeAddRange({
-                    type: Syntax.BooleanLiteralType,
-                    value: value === 'true'
-                }, [startIndex, previous]);
-            }
-
-            context = Context.save();
-            if (value === 'function') {
-                try {
-                    return parseFunctionType();
-                } catch (e) {
-                    context.restore();
-                }
-            }
-
-            return parseTypeName();
-
-        case Token.STRING:
-            next();
-            return maybeAddRange({
-                type: Syntax.StringLiteralType,
-                value: value
-            }, [previous - value.length - 2, previous]);
-
-        case Token.NUMBER:
-            next();
-            return maybeAddRange({
-                type: Syntax.NumericLiteralType,
-                value: value
-            }, [previous - String(value).length, previous]);
-
-        default:
-            utility.throwError('unexpected token');
-        }
-    }
-
-    // TypeExpression :=
-    //     BasicTypeExpression
-    //   | '?' BasicTypeExpression
-    //   | '!' BasicTypeExpression
-    //   | BasicTypeExpression '?'
-    //   | BasicTypeExpression '!'
-    //   | '?'
-    //   | BasicTypeExpression '[]'
-    function parseTypeExpression() {
-        var expr, rangeStart;
-
-        if (token === Token.QUESTION) {
-            rangeStart = index - 1;
-            consume(Token.QUESTION);
-            if (token === Token.COMMA || token === Token.EQUAL || token === Token.RBRACE ||
-                    token === Token.RPAREN || token === Token.PIPE || token === Token.EOF ||
-                    token === Token.RBRACK || token === Token.GT) {
-                return maybeAddRange({
-                    type: Syntax.NullableLiteral
-                }, [rangeStart, previous]);
-            }
-            return maybeAddRange({
-                type: Syntax.NullableType,
-                expression: parseBasicTypeExpression(),
-                prefix: true
-            }, [rangeStart, previous]);
-        } else if (token === Token.BANG) {
-            rangeStart = index - 1;
-            consume(Token.BANG);
-            return maybeAddRange({
-                type: Syntax.NonNullableType,
-                expression: parseBasicTypeExpression(),
-                prefix: true
-            }, [rangeStart, previous]);
-        } else {
-            rangeStart = previous;
-        }
-
-        expr = parseBasicTypeExpression();
-        if (token === Token.BANG) {
-            consume(Token.BANG);
-            return maybeAddRange({
-                type: Syntax.NonNullableType,
-                expression: expr,
-                prefix: false
-            }, [rangeStart, previous]);
-        }
-
-        if (token === Token.QUESTION) {
-            consume(Token.QUESTION);
-            return maybeAddRange({
-                type: Syntax.NullableType,
-                expression: expr,
-                prefix: false
-            }, [rangeStart, previous]);
-        }
-
-        if (token === Token.LBRACK) {
-            consume(Token.LBRACK);
-            expect(Token.RBRACK, 'expected an array-style type declaration (' + value + '[])');
-            return maybeAddRange({
-                type: Syntax.TypeApplication,
-                expression: maybeAddRange({
-                    type: Syntax.NameExpression,
-                    name: 'Array'
-                }, [rangeStart, previous]),
-                applications: [expr]
-            }, [rangeStart, previous]);
-        }
-
-        return expr;
-    }
-
-    // TopLevelTypeExpression :=
-    //      TypeExpression
-    //    | TypeUnionList
-    //
-    // This rule is Google Closure Compiler extension, not ES4
-    // like,
-    //   { number | string }
-    // If strict to ES4, we should write it as
-    //   { (number|string) }
-    function parseTop() {
-        var expr, elements;
-
-        expr = parseTypeExpression();
-        if (token !== Token.PIPE) {
-            return expr;
-        }
-
-        elements = [expr];
-        consume(Token.PIPE);
-        while (true) {
-            elements.push(parseTypeExpression());
-            if (token !== Token.PIPE) {
-                break;
-            }
-            consume(Token.PIPE);
-        }
-
-        return maybeAddRange({
-            type: Syntax.UnionType,
-            elements: elements
-        }, [0, index]);
-    }
-
-    function parseTopParamType() {
-        var expr;
-
-        if (token === Token.REST) {
-            consume(Token.REST);
-            return maybeAddRange({
-                type: Syntax.RestType,
-                expression: parseTop()
-            }, [0, index]);
-        }
-
-        expr = parseTop();
-        if (token === Token.EQUAL) {
-            consume(Token.EQUAL);
-            return maybeAddRange({
-                type: Syntax.OptionalType,
-                expression: expr
-            }, [0, index]);
-        }
-
-        return expr;
-    }
-
-    function parseType(src, opt) {
-        var expr;
-
-        source = src;
-        length = source.length;
-        index = 0;
-        previous = 0;
-        addRange = opt && opt.range;
-        rangeOffset = opt && opt.startIndex || 0;
-
-        next();
-        expr = parseTop();
-
-        if (opt && opt.midstream) {
-            return {
-                expression: expr,
-                index: previous
-            };
-        }
-
-        if (token !== Token.EOF) {
-            utility.throwError('not reach to EOF');
-        }
-
-        return expr;
-    }
-
-    function parseParamType(src, opt) {
-        var expr;
-
-        source = src;
-        length = source.length;
-        index = 0;
-        previous = 0;
-        addRange = opt && opt.range;
-        rangeOffset = opt && opt.startIndex || 0;
-
-        next();
-        expr = parseTopParamType();
-
-        if (opt && opt.midstream) {
-            return {
-                expression: expr,
-                index: previous
-            };
-        }
-
-        if (token !== Token.EOF) {
-            utility.throwError('not reach to EOF');
-        }
-
-        return expr;
-    }
-
-    function stringifyImpl(node, compact, topLevel) {
-        var result, i, iz;
-
-        switch (node.type) {
-        case Syntax.NullableLiteral:
-            result = '?';
-            break;
-
-        case Syntax.AllLiteral:
-            result = '*';
-            break;
-
-        case Syntax.NullLiteral:
-            result = 'null';
-            break;
-
-        case Syntax.UndefinedLiteral:
-            result = 'undefined';
-            break;
-
-        case Syntax.VoidLiteral:
-            result = 'void';
-            break;
-
-        case Syntax.UnionType:
-            if (!topLevel) {
-                result = '(';
-            } else {
-                result = '';
-            }
-
-            for (i = 0, iz = node.elements.length; i < iz; ++i) {
-                result += stringifyImpl(node.elements[i], compact);
-                if ((i + 1) !== iz) {
-                    result += compact ? '|' : ' | ';
-                }
-            }
-
-            if (!topLevel) {
-                result += ')';
-            }
-            break;
-
-        case Syntax.ArrayType:
-            result = '[';
-            for (i = 0, iz = node.elements.length; i < iz; ++i) {
-                result += stringifyImpl(node.elements[i], compact);
-                if ((i + 1) !== iz) {
-                    result += compact ? ',' : ', ';
-                }
-            }
-            result += ']';
-            break;
-
-        case Syntax.RecordType:
-            result = '{';
-            for (i = 0, iz = node.fields.length; i < iz; ++i) {
-                result += stringifyImpl(node.fields[i], compact);
-                if ((i + 1) !== iz) {
-                    result += compact ? ',' : ', ';
-                }
-            }
-            result += '}';
-            break;
-
-        case Syntax.FieldType:
-            if (node.value) {
-                result = node.key + (compact ? ':' : ': ') + stringifyImpl(node.value, compact);
-            } else {
-                result = node.key;
-            }
-            break;
-
-        case Syntax.FunctionType:
-            result = compact ? 'function(' : 'function (';
-
-            if (node['this']) {
-                if (node['new']) {
-                    result += (compact ? 'new:' : 'new: ');
-                } else {
-                    result += (compact ? 'this:' : 'this: ');
-                }
-
-                result += stringifyImpl(node['this'], compact);
-
-                if (node.params.length !== 0) {
-                    result += compact ? ',' : ', ';
-                }
-            }
-
-            for (i = 0, iz = node.params.length; i < iz; ++i) {
-                result += stringifyImpl(node.params[i], compact);
-                if ((i + 1) !== iz) {
-                    result += compact ? ',' : ', ';
-                }
-            }
-
-            result += ')';
-
-            if (node.result) {
-                result += (compact ? ':' : ': ') + stringifyImpl(node.result, compact);
-            }
-            break;
-
-        case Syntax.ParameterType:
-            result = node.name + (compact ? ':' : ': ') + stringifyImpl(node.expression, compact);
-            break;
-
-        case Syntax.RestType:
-            result = '...';
-            if (node.expression) {
-                result += stringifyImpl(node.expression, compact);
-            }
-            break;
-
-        case Syntax.NonNullableType:
-            if (node.prefix) {
-                result = '!' + stringifyImpl(node.expression, compact);
-            } else {
-                result = stringifyImpl(node.expression, compact) + '!';
-            }
-            break;
-
-        case Syntax.OptionalType:
-            result = stringifyImpl(node.expression, compact) + '=';
-            break;
-
-        case Syntax.NullableType:
-            if (node.prefix) {
-                result = '?' + stringifyImpl(node.expression, compact);
-            } else {
-                result = stringifyImpl(node.expression, compact) + '?';
-            }
-            break;
-
-        case Syntax.NameExpression:
-            result = node.name;
-            break;
-
-        case Syntax.TypeApplication:
-            result = stringifyImpl(node.expression, compact) + '.<';
-            for (i = 0, iz = node.applications.length; i < iz; ++i) {
-                result += stringifyImpl(node.applications[i], compact);
-                if ((i + 1) !== iz) {
-                    result += compact ? ',' : ', ';
-                }
-            }
-            result += '>';
-            break;
-
-        case Syntax.StringLiteralType:
-            result = '"' + node.value + '"';
-            break;
-
-        case Syntax.NumericLiteralType:
-            result = String(node.value);
-            break;
-
-        case Syntax.BooleanLiteralType:
-            result = String(node.value);
-            break;
-
-        default:
-            utility.throwError('Unknown type ' + node.type);
-        }
-
-        return result;
-    }
-
-    function stringify(node, options) {
-        if (options == null) {
-            options = {};
-        }
-        return stringifyImpl(node, options.compact, options.topLevel);
-    }
-
-    exports.parseType = parseType;
-    exports.parseParamType = parseParamType;
-    exports.stringify = stringify;
-    exports.Syntax = Syntax;
-}());
-/* vim: set sw=4 ts=4 et tw=80 : */