astexplorer.app/vendor/astexplorer/out/58.js

https://astexplorer.net with ES Modules support and Hot Reloading

(window.webpackJsonp=window.webpackJsonp||[]).push([[58],{"./node_modules/@creditkarma/thrift-parser/dist/main/debugger.js":function(module,exports,__webpack_require__){"use strict";eval("\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst os = __webpack_require__(\"./node_modules/os-browserify/browser.js\");\nconst types_1 = __webpack_require__(\"./node_modules/@creditkarma/thrift-parser/dist/main/types.js\");\nfunction noopReporter(err) {\n    throw new Error(`${err.type}: Line: ${err.loc.start.line}: ${err.message}`);\n}\nexports.noopReporter = noopReporter;\nfunction padLeft(num, str) {\n    while (str.length < num) {\n        str = ' ' + str;\n    }\n    return str;\n}\nfunction indicatorForLocaction(loc) {\n    const indicator = padLeft(loc.start.column, '^');\n    return indicator;\n}\nfunction padStart(length, str) {\n    let paddedStr = str;\n    while (length--) {\n        paddedStr = ' ' + paddedStr;\n    }\n    return paddedStr;\n}\nfunction errorType(type) {\n    switch (type) {\n        case types_1.ErrorType.ParseError:\n            return 'Parse Error:';\n        case types_1.ErrorType.ScanError:\n            return 'Scan Error:';\n    }\n}\nfunction createDebugger(source) {\n    const sourceLines = source.split(os.EOL);\n    const formattedErrors = [];\n    const rawErrors = [];\n    function getSourceLine(lineNumber) {\n        return sourceLines[lineNumber - 1];\n    }\n    function formatError(err) {\n        return {\n            sourceLine: getSourceLine(err.loc.start.line),\n            locIndicator: indicatorForLocaction(err.loc),\n            line: err.loc.start.line,\n            column: err.loc.start.column,\n            message: err.message,\n            type: err.type,\n        };\n    }\n    return {\n        hasError() {\n            return formattedErrors.length > 0;\n        },\n        getErrors() {\n            return rawErrors;\n        },\n        getFormattedErrors() {\n            return formattedErrors;\n        },\n        report(err) {\n            const formattedError = formatError(err);\n            formattedErrors.push(formattedError);\n            rawErrors.push(err);\n        },\n        print() {\n            console.log(`Parse Failure: ${formattedErrors.length} errors found:`);\n            console.log();\n            formattedErrors.forEach((err) => {\n                const prefix = `${err.line} | `;\n                console.log();\n                console.log(`${errorType(err.type)}\\n`);\n                console.log(`Message: ${err.message}`);\n                console.log();\n                console.log(`${prefix}${err.sourceLine}`);\n                console.log(padStart(prefix.length, err.locIndicator));\n                console.log();\n            });\n        },\n    };\n}\nexports.createDebugger = createDebugger;\n//# sourceMappingURL=debugger.js.map\n\n//# sourceURL=webpack:///./node_modules/@creditkarma/thrift-parser/dist/main/debugger.js?")},"./node_modules/@creditkarma/thrift-parser/dist/main/factory.js":function(module,exports,__webpack_require__){"use strict";eval('\nObject.defineProperty(exports, "__esModule", { value: true });\nconst types_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/types.js");\nfunction createParseError(message, loc) {\n    return {\n        type: types_1.ErrorType.ParseError,\n        message,\n        loc,\n    };\n}\nexports.createParseError = createParseError;\nfunction createScanError(message, loc) {\n    return {\n        type: types_1.ErrorType.ScanError,\n        message,\n        loc,\n    };\n}\nexports.createScanError = createScanError;\nfunction createTextLocation(start, end) {\n    return { start, end };\n}\nexports.createTextLocation = createTextLocation;\nfunction createTextPosition(line, column, index) {\n    return { line, column, index };\n}\nexports.createTextPosition = createTextPosition;\nfunction createToken(type, text, loc) {\n    return { type, text, loc };\n}\nexports.createToken = createToken;\nfunction createIdentifier(value, loc, annotations) {\n    return { type: types_1.SyntaxType.Identifier, value, loc, annotations };\n}\nexports.createIdentifier = createIdentifier;\nfunction creataePropertyAssignment(name, initializer, loc) {\n    return {\n        type: types_1.SyntaxType.PropertyAssignment,\n        name,\n        initializer,\n        loc,\n    };\n}\nexports.creataePropertyAssignment = creataePropertyAssignment;\nfunction createFieldDefinition(name, fieldID, requiredness, fieldType, loc, defaultValue = null, annotations, comments = []) {\n    return {\n        type: types_1.SyntaxType.FieldDefinition,\n        name,\n        fieldID,\n        requiredness,\n        fieldType,\n        defaultValue,\n        annotations,\n        comments,\n        loc,\n    };\n}\nexports.createFieldDefinition = createFieldDefinition;\nfunction createFieldID(value, loc) {\n    return {\n        type: types_1.SyntaxType.FieldID,\n        value,\n        loc,\n    };\n}\nexports.createFieldID = createFieldID;\nfunction createStructDefinition(name, fields, loc, comments = []) {\n    return {\n        type: types_1.SyntaxType.StructDefinition,\n        name,\n        fields,\n        comments,\n        loc,\n    };\n}\nexports.createStructDefinition = createStructDefinition;\nfunction createStringLiteral(value, loc) {\n    return {\n        type: types_1.SyntaxType.StringLiteral,\n        value,\n        loc,\n    };\n}\nexports.createStringLiteral = createStringLiteral;\nfunction createIntegerLiteral(value, loc) {\n    return { type: types_1.SyntaxType.IntegerLiteral, value, loc };\n}\nexports.createIntegerLiteral = createIntegerLiteral;\nfunction createHexLiteral(value, loc) {\n    return { type: types_1.SyntaxType.HexLiteral, value, loc };\n}\nexports.createHexLiteral = createHexLiteral;\nfunction createFloatLiteral(value, loc) {\n    return { type: types_1.SyntaxType.FloatLiteral, value, loc };\n}\nexports.createFloatLiteral = createFloatLiteral;\nfunction createExponentialLiteral(value, loc) {\n    return { type: types_1.SyntaxType.ExponentialLiteral, value, loc };\n}\nexports.createExponentialLiteral = createExponentialLiteral;\nfunction createIntConstant(value, loc) {\n    return { type: types_1.SyntaxType.IntConstant, value, loc };\n}\nexports.createIntConstant = createIntConstant;\nfunction createDoubleConstant(value, loc) {\n    return { type: types_1.SyntaxType.DoubleConstant, value, loc };\n}\nexports.createDoubleConstant = createDoubleConstant;\nfunction createBooleanLiteral(value, loc) {\n    return { type: types_1.SyntaxType.BooleanLiteral, value, loc };\n}\nexports.createBooleanLiteral = createBooleanLiteral;\nfunction createKeywordFieldType(type, loc, annotations) {\n    return { type, loc, annotations };\n}\nexports.createKeywordFieldType = createKeywordFieldType;\nfunction createMapFieldType(keyType, valueType, loc, annotations) {\n    return {\n        type: types_1.SyntaxType.MapType,\n        keyType,\n        valueType,\n        loc,\n        annotations,\n    };\n}\nexports.createMapFieldType = createMapFieldType;\nfunction createSetFieldType(valueType, loc, annotations) {\n    return {\n        type: types_1.SyntaxType.SetType,\n        valueType,\n        loc,\n        annotations,\n    };\n}\nexports.createSetFieldType = createSetFieldType;\nfunction createListFieldType(valueType, loc, annotations) {\n    return {\n        type: types_1.SyntaxType.ListType,\n        valueType,\n        loc,\n        annotations,\n    };\n}\nexports.createListFieldType = createListFieldType;\nfunction createConstMap(properties, loc) {\n    return {\n        type: types_1.SyntaxType.ConstMap,\n        properties,\n        loc,\n    };\n}\nexports.createConstMap = createConstMap;\nfunction createConstList(elements, loc) {\n    return {\n        type: types_1.SyntaxType.ConstList,\n        elements,\n        loc,\n    };\n}\nexports.createConstList = createConstList;\n//# sourceMappingURL=factory.js.map\n\n//# sourceURL=webpack:///./node_modules/@creditkarma/thrift-parser/dist/main/factory.js?')},"./node_modules/@creditkarma/thrift-parser/dist/main/index.js":function(module,exports,__webpack_require__){"use strict";eval('/* WEBPACK VAR INJECTION */(function(process) {\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, "__esModule", { value: true });\nconst fs = __webpack_require__("./node_modules/node-libs-browser/mock/empty.js");\nconst path = __webpack_require__("./node_modules/path-browserify/index.js");\nconst debugger_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/debugger.js");\nconst organizer_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/organizer.js");\nconst parser_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/parser.js");\nconst scanner_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/scanner.js");\nconst types_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/types.js");\n__export(__webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/types.js"));\n__export(__webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/factory.js"));\nvar scanner_2 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/scanner.js");\nexports.createScanner = scanner_2.createScanner;\nvar parser_2 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/parser.js");\nexports.createParser = parser_2.createParser;\nexports.defaultOptions = {\n    fastFail: false,\n    rootDir: \'.\',\n    outDir: \'.\',\n    files: [],\n    organize: true,\n};\nfunction parseFiles(options = {}) {\n    const mergedOptions = Object.assign({}, exports.defaultOptions, options);\n    return mergedOptions.files.map((file) => {\n        const filePath = path.resolve(process.cwd(), mergedOptions.rootDir, file);\n        const content = fs.readFileSync(filePath, \'utf-8\');\n        return parse(content, mergedOptions);\n    });\n}\nexports.parseFiles = parseFiles;\nfunction parse(source, options = {}) {\n    const mergedOptions = Object.assign({}, exports.defaultOptions, options);\n    const debug = debugger_1.createDebugger(source);\n    const scanner = scanner_1.createScanner(source, handleError);\n    const tokens = scanner.scan();\n    const parser = parser_1.createParser(tokens, handleError);\n    const intermediate = parser.parse();\n    const thrift = mergedOptions.organize\n        ? organizer_1.organize(intermediate)\n        : intermediate;\n    /**\n     * This is a safe handler for errors that allows the parser and scanner to recover to a\n     * reasonable state after an error and continue with the parse. If an error occurs we will\n     * not return any output, but using this allows us to catch more errors and report them to\n     * the user at once instead of the work flow of find error -> fix error, find error -> fix error.\n     *\n     * @param err\n     */\n    function handleError(err) {\n        debug.report(err);\n        if (mergedOptions.fastFail) {\n            debug.print();\n            throw new Error(err.message);\n        }\n        else {\n            switch (err.type) {\n                case types_1.ErrorType.ParseError:\n                    parser.synchronize();\n                    break;\n                case types_1.ErrorType.ScanError:\n                    scanner.syncronize();\n                    break;\n            }\n        }\n    }\n    if (debug.hasError()) {\n        debug.print();\n        return {\n            type: types_1.SyntaxType.ThriftErrors,\n            errors: debug.getErrors(),\n        };\n    }\n    else {\n        return thrift;\n    }\n}\nexports.parse = parse;\n//# sourceMappingURL=index.js.map\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/process/browser.js")))\n\n//# sourceURL=webpack:///./node_modules/@creditkarma/thrift-parser/dist/main/index.js?')},"./node_modules/@creditkarma/thrift-parser/dist/main/keywords.js":function(module,exports,__webpack_require__){"use strict";eval('\nObject.defineProperty(exports, "__esModule", { value: true });\nconst types_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/types.js");\nexports.KEYWORDS = {\n    namespace: types_1.SyntaxType.NamespaceKeyword,\n    include: types_1.SyntaxType.IncludeKeyword,\n    cpp_include: types_1.SyntaxType.CppIncludeKeyword,\n    const: types_1.SyntaxType.ConstKeyword,\n    struct: types_1.SyntaxType.StructKeyword,\n    service: types_1.SyntaxType.ServiceKeyword,\n    extends: types_1.SyntaxType.ExtendsKeyword,\n    throws: types_1.SyntaxType.ThrowsKeyword,\n    typedef: types_1.SyntaxType.TypedefKeyword,\n    union: types_1.SyntaxType.UnionKeyword,\n    enum: types_1.SyntaxType.EnumKeyword,\n    senum: types_1.SyntaxType.SenumKeyword,\n    list: types_1.SyntaxType.ListKeyword,\n    set: types_1.SyntaxType.SetKeyword,\n    map: types_1.SyntaxType.MapKeyword,\n    double: types_1.SyntaxType.DoubleKeyword,\n    i8: types_1.SyntaxType.I8Keyword,\n    i16: types_1.SyntaxType.I16Keyword,\n    i32: types_1.SyntaxType.I32Keyword,\n    i64: types_1.SyntaxType.I64Keyword,\n    exception: types_1.SyntaxType.ExceptionKeyword,\n    binary: types_1.SyntaxType.BinaryKeyword,\n    bool: types_1.SyntaxType.BoolKeyword,\n    byte: types_1.SyntaxType.ByteKeyword,\n    required: types_1.SyntaxType.RequiredKeyword,\n    optional: types_1.SyntaxType.OptionalKeyword,\n    string: types_1.SyntaxType.StringKeyword,\n    true: types_1.SyntaxType.TrueKeyword,\n    false: types_1.SyntaxType.FalseKeyword,\n    void: types_1.SyntaxType.VoidKeyword,\n    oneway: types_1.SyntaxType.OnewayKeyword,\n};\n//# sourceMappingURL=keywords.js.map\n\n//# sourceURL=webpack:///./node_modules/@creditkarma/thrift-parser/dist/main/keywords.js?')},"./node_modules/@creditkarma/thrift-parser/dist/main/organizer.js":function(module,exports,__webpack_require__){"use strict";eval('\nObject.defineProperty(exports, "__esModule", { value: true });\nconst types_1 = __webpack_require__("./node_modules/@creditkarma/thrift-parser/dist/main/types.js");\nfunction organize(raw) {\n    const namespaces = [];\n    const includes = [];\n    const constants = [];\n    const enums = [];\n    const typedefs = [];\n    const structs = [];\n    const unions = [];\n    const exceptions = [];\n    const services = [];\n    for (const next of raw.body) {\n        switch (next.type) {\n            case types_1.SyntaxType.NamespaceDefinition:\n                namespaces.push(next);\n                break;\n            case types_1.SyntaxType.IncludeDefinition:\n                includes.push(next);\n                break;\n            case types_1.SyntaxType.CppIncludeDefinition:\n                // We\'re not generating C++\n                break;\n            case types_1.SyntaxType.ConstDefinition:\n                constants.push(next);\n                break;\n            case types_1.SyntaxType.EnumDefinition:\n                enums.push(next);\n                break;\n            case types_1.SyntaxType.StructDefinition:\n                structs.push(next);\n                break;\n            case types_1.SyntaxType.UnionDefinition:\n                unions.push(next);\n                break;\n            case types_1.SyntaxType.ExceptionDefinition:\n                exceptions.push(next);\n                break;\n            case types_1.SyntaxType.TypedefDefinition:\n                typedefs.push(next);\n                break;\n            case types_1.SyntaxType.ServiceDefinition:\n                services.push(next);\n                break;\n            default:\n                const msg = next;\n                throw new Error(`Unexpected statement type found: ${msg}`);\n        }\n    }\n    return {\n        type: types_1.SyntaxType.ThriftDocument,\n        body: [\n            ...namespaces,\n            ...includes,\n            ...enums,\n            ...typedefs,\n            ...constants,\n            ...structs,\n            ...unions,\n            ...exceptions,\n            ...services,\n        ],\n        tokens: raw.tokens,\n    };\n}\nexports.organize = organize;\n//# sourceMappingURL=organizer.js.map\n\n//# sourceURL=webpack:///./node_modules/@creditkarma/thrift-parser/dist/main/organizer.js?')},"./node_modules/@creditkarma/thrift-parser/dist/main/parser.js":function(module,exports,__webpack_require__){"use strict";eval("\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst types_1 = __webpack_require__(\"./node_modules/@creditkarma/thrift-parser/dist/main/types.js\");\nconst factory_1 = __webpack_require__(\"./node_modules/@creditkarma/thrift-parser/dist/main/factory.js\");\nconst debugger_1 = __webpack_require__(\"./node_modules/@creditkarma/thrift-parser/dist/main/debugger.js\");\nfunction isStatementBeginning(token) {\n    switch (token.type) {\n        case types_1.SyntaxType.NamespaceKeyword:\n        case types_1.SyntaxType.IncludeKeyword:\n        case types_1.SyntaxType.ConstKeyword:\n        case types_1.SyntaxType.StructKeyword:\n        case types_1.SyntaxType.UnionKeyword:\n        case types_1.SyntaxType.ExceptionKeyword:\n        case types_1.SyntaxType.ServiceKeyword:\n        case types_1.SyntaxType.TypedefKeyword:\n        case types_1.SyntaxType.EnumKeyword:\n            return true;\n        default:\n            return false;\n    }\n}\nclass ParseError extends Error {\n    constructor(msg, loc) {\n        super(msg);\n        this.message = msg;\n        this.loc = loc;\n    }\n}\nfunction createParser(tokens, report = debugger_1.noopReporter) {\n    let comments = [];\n    let currentIndex = 0;\n    // PUBLIC\n    function parse() {\n        const thrift = {\n            type: types_1.SyntaxType.ThriftDocument,\n            body: [],\n        };\n        while (!isAtEnd()) {\n            try {\n                const statement = parseStatement();\n                if (statement !== null) {\n                    thrift.body.push(statement);\n                }\n            }\n            catch (e) {\n                report(factory_1.createParseError(e.message, e.loc));\n            }\n        }\n        return thrift;\n    }\n    // Finds the beginning of the next statement so we can continue parse after error.\n    function synchronize() {\n        while (!isAtEnd() && !isStatementBeginning(currentToken())) {\n            advance();\n        }\n    }\n    function parseStatement() {\n        const next = currentToken();\n        // All Thrift statements must start with one of these types\n        switch (next.type) {\n            case types_1.SyntaxType.NamespaceKeyword:\n                return parseNamespace();\n            case types_1.SyntaxType.IncludeKeyword:\n                return parseInclude();\n            case types_1.SyntaxType.ConstKeyword:\n                return parseConst();\n            case types_1.SyntaxType.StructKeyword:\n                return parseStruct();\n            case types_1.SyntaxType.UnionKeyword:\n                return parseUnion();\n            case types_1.SyntaxType.ExceptionKeyword:\n                return parseException();\n            case types_1.SyntaxType.ServiceKeyword:\n                return parseService();\n            case types_1.SyntaxType.TypedefKeyword:\n                return parseTypedef();\n            case types_1.SyntaxType.EnumKeyword:\n                return parseEnum();\n            case types_1.SyntaxType.CommentBlock:\n            case types_1.SyntaxType.CommentLine:\n                consumeComments();\n                return null;\n            default:\n                throw reportError(`Invalid start to Thrift statement ${next.text}`);\n        }\n    }\n    // IncludeDefinition → 'include' StringLiteral\n    function parseInclude() {\n        const _keywordToken = consume(types_1.SyntaxType.IncludeKeyword);\n        const keywordToken = requireValue(_keywordToken, `'indcluded' keyword expected`);\n        const _pathToken = consume(types_1.SyntaxType.StringLiteral);\n        const pathToken = requireValue(_pathToken, `Include statement must include a path as string literal`);\n        return {\n            type: types_1.SyntaxType.IncludeDefinition,\n            path: factory_1.createStringLiteral(pathToken.text, pathToken.loc),\n            comments: getComments(),\n            loc: factory_1.createTextLocation(keywordToken.loc.start, pathToken.loc.end),\n        };\n    }\n    // ServiceDefinition → 'service' Identifier ( 'extends' Identifier )? '{' Function* '} Annotations?'\n    function parseService() {\n        const leadingComments = getComments();\n        const _keywordToken = consume(types_1.SyntaxType.ServiceKeyword);\n        const keywordToken = requireValue(_keywordToken, `Unable to find service keyword for service`);\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Unable to find identifier for service`);\n        const extendsId = parseExtends();\n        const _openBrace = consume(types_1.SyntaxType.LeftBraceToken);\n        const openBrace = requireValue(_openBrace, `Expected opening curly brace`);\n        const functions = parseFunctions();\n        const _closeBrace = consume(types_1.SyntaxType.RightBraceToken);\n        const closeBrace = requireValue(_closeBrace, `Expected closing curly brace`);\n        const annotations = parseAnnotations();\n        const location = factory_1.createTextLocation(keywordToken.loc.start, closeBrace.loc.end);\n        return {\n            type: types_1.SyntaxType.ServiceDefinition,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            extends: extendsId,\n            functions,\n            annotations,\n            comments: leadingComments,\n            loc: location,\n        };\n    }\n    function parseExtends() {\n        if (checkText('extends')) {\n            const _keywordToken = consume(types_1.SyntaxType.ExtendsKeyword);\n            const keywordToken = requireValue(_keywordToken, `'extends keyword expected`);\n            const _nameToken = consume(types_1.SyntaxType.Identifier);\n            const nameToken = requireValue(_nameToken, `Identifier expected after 'extends' keyword`);\n            return factory_1.createIdentifier(nameToken.text, factory_1.createTextLocation(keywordToken.loc.start, nameToken.loc.end));\n        }\n        else {\n            return null;\n        }\n    }\n    function parseFunctions() {\n        const functions = [];\n        while (!check(types_1.SyntaxType.RightBraceToken)) {\n            if (check(types_1.SyntaxType.CommentBlock, types_1.SyntaxType.CommentLine)) {\n                advance();\n            }\n            else {\n                functions.push(parseFunction());\n                if (isStatementBeginning(currentToken())) {\n                    throw reportError(`Closing curly brace expected, but new statement found`);\n                }\n                else if (check(types_1.SyntaxType.EOF)) {\n                    throw reportError(`Closing curly brace expected but reached end of file`);\n                }\n            }\n        }\n        return functions;\n    }\n    // Function → 'oneway'? FunctionType Identifier '(' Field* ')' Throws? Annotations? ListSeparator?\n    function parseFunction() {\n        const leadingComments = getComments();\n        const onewayToken = consume(types_1.SyntaxType.OnewayKeyword);\n        const returnType = parseFunctionType();\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Unable to find function identifier`);\n        const params = parseParameterFields();\n        const throws = parseThrows();\n        const annotations = parseAnnotations();\n        const listSeparator = readListSeparator();\n        const endLoc = listSeparator !== null\n            ? listSeparator.loc\n            : throws !== null\n                ? throws.loc\n                : params.loc;\n        return {\n            type: types_1.SyntaxType.FunctionDefinition,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            returnType,\n            fields: params.fields,\n            throws: throws !== null ? throws.fields : [],\n            annotations,\n            comments: leadingComments,\n            oneway: onewayToken !== null,\n            modifiers: onewayToken !== null ? [onewayToken] : [],\n            loc: {\n                start: returnType.loc.start,\n                end: endLoc.end,\n            },\n        };\n    }\n    function parseParameterFields() {\n        const fields = [];\n        const _openParen = consume(types_1.SyntaxType.LeftParenToken);\n        const openParen = requireValue(_openParen, `Opening paren expected to start list of fields`);\n        while (!check(types_1.SyntaxType.RightParenToken)) {\n            readListSeparator();\n            fields.push(parseField());\n            if (isStatementBeginning(currentToken())) {\n                throw reportError(`Closing paren ')' expected, but new statement found`);\n            }\n            else if (check(types_1.SyntaxType.EOF)) {\n                throw reportError(`Closing paren ')' expected but reached end of file`);\n            }\n        }\n        const _closeParen = consume(types_1.SyntaxType.RightParenToken);\n        const closeParen = requireValue(_closeParen, `Closing paren expected to end list of fields`);\n        return {\n            type: types_1.SyntaxType.ParametersDefinition,\n            fields,\n            loc: {\n                start: openParen.loc.start,\n                end: closeParen.loc.end,\n            },\n        };\n    }\n    // Throws → 'throws' '(' Field* ')'\n    function parseThrows() {\n        if (check(types_1.SyntaxType.ThrowsKeyword)) {\n            const _keywordToken = consume(types_1.SyntaxType.ThrowsKeyword);\n            const keywordToken = requireValue(_keywordToken, `'throws' keyword expected`);\n            const params = parseParameterFields();\n            return {\n                type: types_1.SyntaxType.ThrowsDefinition,\n                fields: params.fields,\n                loc: {\n                    start: keywordToken.loc.start,\n                    end: params.loc.end,\n                },\n            };\n        }\n        return null;\n    }\n    // Namespace → 'namespace' ( NamespaceScope Identifier )\n    function parseNamespace() {\n        const _keywordToken = consume(types_1.SyntaxType.NamespaceKeyword);\n        const keywordToken = requireValue(_keywordToken, `'namespace' keyword expected`);\n        const _scopeToken = consume(types_1.SyntaxType.Identifier);\n        const scopeToken = requireValue(_scopeToken, `Unable to find scope identifier for namespace`);\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Unable to find name identifier for namespace`);\n        return {\n            type: types_1.SyntaxType.NamespaceDefinition,\n            scope: factory_1.createIdentifier(scopeToken.text, scopeToken.loc),\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            comments: getComments(),\n            loc: factory_1.createTextLocation(keywordToken.loc.start, nameToken.loc.end),\n        };\n    }\n    // ConstDefinition → 'const' FieldType Identifier '=' ConstValue Annotations? ListSeparator?\n    function parseConst() {\n        const leadingComments = getComments();\n        const _keywordToken = consume(types_1.SyntaxType.ConstKeyword);\n        const keywordToken = requireValue(_keywordToken, `'const' keyword expected`);\n        const fieldType = parseFieldType();\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Const definition must have a name`);\n        const _initializer = parseValueAssignment();\n        const initializer = requireValue(_initializer, `Const must be initialized to a value`);\n        const annotations = parseAnnotations();\n        readListSeparator();\n        return {\n            type: types_1.SyntaxType.ConstDefinition,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            fieldType,\n            initializer,\n            annotations,\n            comments: leadingComments,\n            loc: {\n                start: keywordToken.loc.start,\n                end: initializer.loc.end,\n            },\n        };\n    }\n    function parseValueAssignment() {\n        if (check(types_1.SyntaxType.EqualToken)) {\n            advance();\n            return parseValue();\n        }\n        return null;\n    }\n    // Annotations → '(' Annotation* ')'\n    function parseAnnotations() {\n        if (check(types_1.SyntaxType.LeftParenToken)) {\n            const annotations = [];\n            const startToken = advance();\n            while (!check(types_1.SyntaxType.RightParenToken)) {\n                annotations.push(parseAnnotation());\n            }\n            const endToken = advance();\n            return {\n                annotations,\n                type: types_1.SyntaxType.Annotations,\n                loc: factory_1.createTextLocation(startToken.loc.start, endToken.loc.end),\n            };\n        }\n        return undefined;\n    }\n    // Annotation → Identifier ('=' StringLiteral)? ListSeparator?\n    function parseAnnotation() {\n        const nameToken = requireValue(consume(types_1.SyntaxType.Identifier), `Annotation must have a name`);\n        let valueToken;\n        if (check(types_1.SyntaxType.EqualToken)) {\n            advance();\n            valueToken = requireValue(consume(types_1.SyntaxType.StringLiteral), `Annotation must have a value`);\n        }\n        readListSeparator();\n        return {\n            type: types_1.SyntaxType.Annotation,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            value: valueToken\n                ? factory_1.createStringLiteral(valueToken.text, valueToken.loc)\n                : undefined,\n            loc: factory_1.createTextLocation(nameToken.loc.start, (valueToken || nameToken).loc.end),\n        };\n    }\n    // TypedefDefinition → 'typedef' FieldType Identifier\n    function parseTypedef() {\n        const _keywordToken = consume(types_1.SyntaxType.TypedefKeyword);\n        const keywordToken = requireValue(_keywordToken, `'typedef' keyword expected`);\n        const type = parseFieldType();\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Typedef is expected to have name and none found`);\n        const leadingComments = getComments();\n        const annotations = parseAnnotations();\n        return {\n            type: types_1.SyntaxType.TypedefDefinition,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            definitionType: type,\n            annotations,\n            comments: leadingComments,\n            loc: {\n                start: keywordToken.loc.start,\n                end: nameToken.loc.end,\n            },\n        };\n    }\n    // EnumDefinition → 'enum' Identifier '{' EnumMember* '} Annotations?'\n    function parseEnum() {\n        const leadingComments = getComments();\n        const _keywordToken = consume(types_1.SyntaxType.EnumKeyword);\n        const keywordToken = requireValue(_keywordToken, `'enum' keyword expected`);\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Expected identifier for enum definition`);\n        const openBrace = consume(types_1.SyntaxType.LeftBraceToken);\n        requireValue(openBrace, `Expected opening brace`);\n        const members = parseEnumMembers();\n        const _closeBrace = consume(types_1.SyntaxType.RightBraceToken);\n        const closeBrace = requireValue(_closeBrace, `Expected closing brace`);\n        const annotations = parseAnnotations();\n        const loc = {\n            start: keywordToken.loc.start,\n            end: closeBrace.loc.end,\n        };\n        return {\n            type: types_1.SyntaxType.EnumDefinition,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            members,\n            annotations,\n            comments: leadingComments,\n            loc,\n        };\n    }\n    function parseEnumMembers() {\n        const members = [];\n        while (!check(types_1.SyntaxType.RightBraceToken)) {\n            if (check(types_1.SyntaxType.CommentBlock, types_1.SyntaxType.CommentLine)) {\n                advance();\n            }\n            else {\n                members.push(parseEnumMember());\n                // consume list separator if there is one\n                readListSeparator();\n                if (isStatementBeginning(currentToken())) {\n                    throw reportError(`Closing curly brace expected, but new statement found`);\n                }\n                else if (check(types_1.SyntaxType.EOF)) {\n                    throw reportError(`Closing curly brace expected but reached end of file`);\n                }\n            }\n        }\n        return members;\n    }\n    // EnumMember → (Identifier ('=' IntConstant)? Annotations? ListSeparator?)*\n    function parseEnumMember() {\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `EnumMember must have identifier`);\n        let loc = null;\n        let initializer = null;\n        if (consume(types_1.SyntaxType.EqualToken) !== null) {\n            const _numToken = consume(types_1.SyntaxType.IntegerLiteral, types_1.SyntaxType.HexLiteral);\n            const numToken = requireValue(_numToken, `Equals token \"=\" must be followed by an Integer`);\n            initializer = parseIntValue(numToken);\n            loc = factory_1.createTextLocation(nameToken.loc.start, initializer.loc.end);\n        }\n        else {\n            loc = factory_1.createTextLocation(nameToken.loc.start, nameToken.loc.end);\n        }\n        const annotations = parseAnnotations();\n        return {\n            type: types_1.SyntaxType.EnumMember,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            initializer,\n            annotations,\n            comments: getComments(),\n            loc,\n        };\n    }\n    // StructLike → ('struct' | 'union' | 'exception') Identifier 'xsd_all'? '{' Field* '} Annotations?'\n    function parseStructLikeInterface() {\n        const leadingComments = getComments();\n        const _keywordToken = consume(types_1.SyntaxType.StructKeyword, types_1.SyntaxType.UnionKeyword, types_1.SyntaxType.ExceptionKeyword);\n        const keywordToken = requireValue(_keywordToken, `'struct | union | exception' expected`);\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Struct-like must have an identifier`);\n        const openBrace = consume(types_1.SyntaxType.LeftBraceToken);\n        requireValue(openBrace, `Struct-like body must begin with opening curly brace '{'`);\n        const fields = parseFields();\n        const _closeBrace = consume(types_1.SyntaxType.RightBraceToken);\n        const closeBrace = requireValue(_closeBrace, `Struct-like body must end with a closing curly brace '}'`);\n        const annotations = parseAnnotations();\n        return {\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            fields,\n            annotations,\n            comments: leadingComments,\n            loc: {\n                start: keywordToken.loc.start,\n                end: closeBrace.loc.end,\n            },\n        };\n    }\n    // StructDefinition → 'struct' Identifier 'xsd_all'? '{' Field* '} Annotations?'\n    function parseStruct() {\n        const parsedData = parseStructLikeInterface();\n        return {\n            type: types_1.SyntaxType.StructDefinition,\n            name: parsedData.name,\n            fields: parsedData.fields,\n            annotations: parsedData.annotations,\n            comments: parsedData.comments,\n            loc: parsedData.loc,\n        };\n    }\n    // UnioinDefinition → 'union' Identifier 'xsd_all'? '{' Field* '} Annotations?'\n    function parseUnion() {\n        const parsedData = parseStructLikeInterface();\n        return {\n            type: types_1.SyntaxType.UnionDefinition,\n            name: parsedData.name,\n            fields: parsedData.fields.map((next) => {\n                // As per the Thrift spec, all union fields are optional\n                next.requiredness = 'optional';\n                return next;\n            }),\n            annotations: parsedData.annotations,\n            comments: parsedData.comments,\n            loc: parsedData.loc,\n        };\n    }\n    // ExceptionDefinition → 'exception' Identifier '{' Field* '} Annotations?'\n    function parseException() {\n        const parsedData = parseStructLikeInterface();\n        return {\n            type: types_1.SyntaxType.ExceptionDefinition,\n            name: parsedData.name,\n            fields: parsedData.fields,\n            annotations: parsedData.annotations,\n            comments: parsedData.comments,\n            loc: parsedData.loc,\n        };\n    }\n    function parseFields() {\n        const fields = [];\n        while (!check(types_1.SyntaxType.RightBraceToken)) {\n            if (check(types_1.SyntaxType.CommentBlock, types_1.SyntaxType.CommentLine)) {\n                advance();\n            }\n            else {\n                fields.push(parseField());\n                if (isStatementBeginning(currentToken())) {\n                    throw reportError(`Closing curly brace expected, but new statement found`);\n                }\n                else if (check(types_1.SyntaxType.EOF)) {\n                    throw reportError(`Closing curly brace expected but reached end of file`);\n                }\n            }\n        }\n        return fields;\n    }\n    // Field → FieldID? FieldReq? FieldType Identifier ('= ConstValue)? XsdFieldOptions Annotations? ListSeparator?\n    function parseField() {\n        const startLoc = currentToken().loc;\n        const fieldID = parseFieldId();\n        const fieldRequired = parserequireValuedness();\n        const fieldType = parseFieldType();\n        const _nameToken = consume(types_1.SyntaxType.Identifier);\n        const nameToken = requireValue(_nameToken, `Unable to find identifier for field`);\n        const defaultValue = parseValueAssignment();\n        const annotations = parseAnnotations();\n        const listSeparator = readListSeparator();\n        const endLoc = listSeparator !== null\n            ? listSeparator.loc\n            : defaultValue !== null\n                ? defaultValue.loc\n                : nameToken.loc;\n        const location = factory_1.createTextLocation(startLoc.start, endLoc.end);\n        return {\n            type: types_1.SyntaxType.FieldDefinition,\n            name: factory_1.createIdentifier(nameToken.text, nameToken.loc),\n            fieldID,\n            fieldType,\n            requiredness: fieldRequired,\n            defaultValue,\n            comments: getComments(),\n            annotations,\n            loc: location,\n        };\n    }\n    // ListSeparator → ',' | ';'\n    function readListSeparator() {\n        if (check(types_1.SyntaxType.CommaToken, types_1.SyntaxType.SemicolonToken)) {\n            return advance();\n        }\n        return null;\n    }\n    // FieldRequired → 'required' | 'optional'\n    function parserequireValuedness() {\n        const current = currentToken();\n        if (current.text === 'required' || current.text === 'optional') {\n            advance();\n            return current.text;\n        }\n        return null;\n    }\n    // FieldID → IntConstant ':'\n    function parseFieldId() {\n        if (currentToken().type === types_1.SyntaxType.IntegerLiteral &&\n            peek().type === types_1.SyntaxType.ColonToken) {\n            const fieldIDToken = consume(types_1.SyntaxType.IntegerLiteral);\n            const colonToken = consume(types_1.SyntaxType.ColonToken);\n            // return value of number token\n            return factory_1.createFieldID(parseInt(fieldIDToken.text, 10), factory_1.createTextLocation(fieldIDToken.loc.start, colonToken.loc.end));\n        }\n        else {\n            return null;\n        }\n    }\n    // ConstValue → Literal | ConstMap | ConstList\n    function parseValue() {\n        const next = advance();\n        switch (next.type) {\n            case types_1.SyntaxType.Identifier:\n                return factory_1.createIdentifier(next.text, next.loc);\n            case types_1.SyntaxType.StringLiteral:\n                return factory_1.createStringLiteral(next.text, next.loc);\n            case types_1.SyntaxType.IntegerLiteral:\n            case types_1.SyntaxType.HexLiteral:\n                return parseIntValue(next);\n            case types_1.SyntaxType.FloatLiteral:\n            case types_1.SyntaxType.ExponentialLiteral:\n                return parseDoubleValue(next);\n            case types_1.SyntaxType.TrueKeyword:\n                return factory_1.createBooleanLiteral(true, next.loc);\n            case types_1.SyntaxType.FalseKeyword:\n                return factory_1.createBooleanLiteral(false, next.loc);\n            case types_1.SyntaxType.LeftBraceToken:\n                return parseMapValue();\n            case types_1.SyntaxType.LeftBracketToken:\n                return parseListValue();\n            default:\n                return null;\n        }\n    }\n    function parseIntValue(token) {\n        switch (token.type) {\n            case types_1.SyntaxType.IntegerLiteral:\n                return factory_1.createIntConstant(factory_1.createIntegerLiteral(token.text, token.loc), token.loc);\n            case types_1.SyntaxType.HexLiteral:\n                return factory_1.createIntConstant(factory_1.createHexLiteral(token.text, token.loc), token.loc);\n            default:\n                throw reportError(`IntConstant expected but found: ${token.type}`);\n        }\n    }\n    function parseDoubleValue(token) {\n        switch (token.type) {\n            case types_1.SyntaxType.FloatLiteral:\n                return factory_1.createDoubleConstant(factory_1.createFloatLiteral(token.text, token.loc), token.loc);\n            case types_1.SyntaxType.ExponentialLiteral:\n                return factory_1.createDoubleConstant(factory_1.createExponentialLiteral(token.text, token.loc), token.loc);\n            default:\n                throw reportError(`DoubleConstant expected but found: ${token.type}`);\n        }\n    }\n    // ConstMap → '{' (ConstValue ':' ConstValue ListSeparator?)* '}'\n    function parseMapValue() {\n        // The parseValue method has already advanced the cursor\n        const startLoc = currentToken().loc;\n        const properties = check(types_1.SyntaxType.RightBraceToken)\n            ? []\n            : readMapValues();\n        const _closeBrace = consume(types_1.SyntaxType.RightBraceToken);\n        const closeBrace = requireValue(_closeBrace, `Closing brace missing from map definition`);\n        const endLoc = closeBrace.loc;\n        const location = {\n            start: startLoc.start,\n            end: endLoc.end,\n        };\n        return factory_1.createConstMap(properties, location);\n    }\n    // ConstList → '[' (ConstValue ListSeparator?)* ']'\n    function parseListValue() {\n        // The parseValue method has already advanced the cursor\n        const startLoc = currentToken().loc;\n        const elements = check(types_1.SyntaxType.RightBracketToken)\n            ? []\n            : readListValues();\n        const _closeBrace = consume(types_1.SyntaxType.RightBracketToken);\n        const closeBrace = requireValue(_closeBrace, `Closing square-bracket missing from list definition`);\n        const endLoc = closeBrace.loc;\n        return factory_1.createConstList(elements, {\n            start: startLoc.start,\n            end: endLoc.end,\n        });\n    }\n    function readMapValues() {\n        const properties = [];\n        while (true) {\n            const _key = parseValue();\n            const key = requireValue(_key, 'Key expected for map value');\n            const semicolon = consume(types_1.SyntaxType.ColonToken);\n            requireValue(semicolon, `Semicolon expected after key in map property assignment`);\n            const _value = parseValue();\n            const value = requireValue(_value, '');\n            properties.push(factory_1.creataePropertyAssignment(key, value, {\n                start: key.loc.start,\n                end: value.loc.end,\n            }));\n            if (check(types_1.SyntaxType.CommaToken)) {\n                advance();\n                // trailing comma\n                if (check(types_1.SyntaxType.RightBraceToken)) {\n                    break;\n                }\n            }\n            else {\n                break;\n            }\n        }\n        return properties;\n    }\n    function readListValues() {\n        const elements = [];\n        while (true) {\n            const value = parseValue();\n            if (value !== null) {\n                elements.push(value);\n            }\n            if (check(types_1.SyntaxType.CommaToken, types_1.SyntaxType.SemicolonToken)) {\n                advance();\n                // trailing comma\n                if (check(types_1.SyntaxType.RightBracketToken)) {\n                    break;\n                }\n            }\n            else {\n                break;\n            }\n        }\n        return elements;\n    }\n    // FunctionType → FieldType | 'void'\n    function parseFunctionType() {\n        const typeToken = consume(types_1.SyntaxType.VoidKeyword);\n        if (typeToken !== null) {\n            return {\n                type: types_1.SyntaxType.VoidKeyword,\n                loc: typeToken.loc,\n            };\n        }\n        else {\n            return parseFieldType();\n        }\n    }\n    // FieldType → Identifier | BaseType | ContainerType\n    function parseFieldType() {\n        const typeToken = advance();\n        switch (typeToken.type) {\n            case types_1.SyntaxType.Identifier:\n                return factory_1.createIdentifier(typeToken.text, typeToken.loc, parseAnnotations());\n            case types_1.SyntaxType.MapKeyword:\n                return parseMapType();\n            case types_1.SyntaxType.ListKeyword:\n                return parseListType();\n            case types_1.SyntaxType.SetKeyword:\n                return parseSetType();\n            case types_1.SyntaxType.BinaryKeyword:\n            case types_1.SyntaxType.BoolKeyword:\n            case types_1.SyntaxType.ByteKeyword:\n            case types_1.SyntaxType.StringKeyword:\n            case types_1.SyntaxType.I8Keyword:\n            case types_1.SyntaxType.I16Keyword:\n            case types_1.SyntaxType.I32Keyword:\n            case types_1.SyntaxType.I64Keyword:\n            case types_1.SyntaxType.DoubleKeyword:\n                return factory_1.createKeywordFieldType(typeToken.type, typeToken.loc, parseAnnotations());\n            default:\n                throw reportError(`FieldType expected but found: ${typeToken.type}`);\n        }\n    }\n    // MapType → 'map' CppType? '<' FieldType ',' FieldType '>'\n    function parseMapType() {\n        const _openBracket = consume(types_1.SyntaxType.LessThanToken);\n        const openBracket = requireValue(_openBracket, `Map needs to defined contained types`);\n        const keyType = parseFieldType();\n        const _commaToken = consume(types_1.SyntaxType.CommaToken);\n        const commaToken = requireValue(_commaToken, `Comma expected to separate map types <key, value>`);\n        const valueType = parseFieldType();\n        const _closeBracket = consume(types_1.SyntaxType.GreaterThanToken);\n        const closeBracket = requireValue(_closeBracket, `Map needs to defined contained types`);\n        const location = {\n            start: openBracket.loc.start,\n            end: closeBracket.loc.end,\n        };\n        return factory_1.createMapFieldType(keyType, valueType, location, parseAnnotations());\n    }\n    // SetType → 'set' CppType? '<' FieldType '>'\n    function parseSetType() {\n        const _openBracket = consume(types_1.SyntaxType.LessThanToken);\n        const openBracket = requireValue(_openBracket, `Map needs to defined contained types`);\n        const valueType = parseFieldType();\n        const _closeBracket = consume(types_1.SyntaxType.GreaterThanToken);\n        const closeBracket = requireValue(_closeBracket, `Map needs to defined contained types`);\n        return {\n            type: types_1.SyntaxType.SetType,\n            valueType,\n            loc: {\n                start: openBracket.loc.start,\n                end: closeBracket.loc.end,\n            },\n            annotations: parseAnnotations(),\n        };\n    }\n    // ListType → 'list' '<' FieldType '>' CppType?\n    function parseListType() {\n        const _openBracket = consume(types_1.SyntaxType.LessThanToken);\n        const openBracket = requireValue(_openBracket, `Map needs to defined contained types`);\n        const valueType = parseFieldType();\n        const _closeBracket = consume(types_1.SyntaxType.GreaterThanToken);\n        const closeBracket = requireValue(_closeBracket, `Map needs to defined contained types`);\n