{"version":3,"file":"vendor.graphql-language-service-parser.d128f39b136c9015.js","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnHO;AACP,aAAa;AACb;AACO;AACP,aAAa;AACb;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,aAAa;AACb;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;;;AC3BwD;AACzB;AACxB;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA,uDAAuD,MAAM;AAC7D;AACA,wGAAwG,EAAE;AAC1G;AACA;AACO;AACP,eAAe,IAAI;AACnB;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,iBAAI;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,QAAQ,GAAG,CAAC,UAAI;AAChB,QAAQ,GAAG;AACX,QAAQ,IAAI;AACZ;AACA;AACA;AACA;AACA,QAAQ,GAA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;AACb;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;ACtR0D;AAC3B;AAChB;AACf,6CAA6C,SAAS;AACtD,cAAc,QAAQ;AACtB,gBAAgB,UAAU;AAC1B,oBAAoB;AACpB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,iBAAI;AAC3D;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,oDAAoD;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,mBAAM,GAAG;AACjC;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,mBAAM;AACV;AACA;AACA;AACA,SAAS,mBAAM;AACf;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;;ACnN+B;AACxB;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,gDAAgD,EAAE,iBAAI;AAC7D;;AC/B+D;AACL;AACF;AACC;AACjC;AACxB","sources":["webpack://admin/./node_modules/graphql-language-service-parser/esm/CharacterStream.js","webpack://admin/./node_modules/graphql-language-service-parser/esm/RuleHelpers.js","webpack://admin/./node_modules/graphql-language-service-parser/esm/Rules.js","webpack://admin/./node_modules/graphql-language-service-parser/esm/onlineParser.js","webpack://admin/./node_modules/graphql-language-service-parser/esm/types.js","webpack://admin/./node_modules/graphql-language-service-parser/esm/index.js"],"sourcesContent":["export default class CharacterStream {\n    constructor(sourceText) {\n        this.getStartOfToken = () => this._start;\n        this.getCurrentPosition = () => this._pos;\n        this.eol = () => this._sourceText.length === this._pos;\n        this.sol = () => this._pos === 0;\n        this.peek = () => {\n            return this._sourceText.charAt(this._pos)\n                ? this._sourceText.charAt(this._pos)\n                : null;\n        };\n        this.next = () => {\n            const char = this._sourceText.charAt(this._pos);\n            this._pos++;\n            return char;\n        };\n        this.eat = (pattern) => {\n            const isMatched = this._testNextCharacter(pattern);\n            if (isMatched) {\n                this._start = this._pos;\n                this._pos++;\n                return this._sourceText.charAt(this._pos - 1);\n            }\n            return undefined;\n        };\n        this.eatWhile = (match) => {\n            let isMatched = this._testNextCharacter(match);\n            let didEat = false;\n            if (isMatched) {\n                didEat = isMatched;\n                this._start = this._pos;\n            }\n            while (isMatched) {\n                this._pos++;\n                isMatched = this._testNextCharacter(match);\n                didEat = true;\n            }\n            return didEat;\n        };\n        this.eatSpace = () => this.eatWhile(/[\\s\\u00a0]/);\n        this.skipToEnd = () => {\n            this._pos = this._sourceText.length;\n        };\n        this.skipTo = (position) => {\n            this._pos = position;\n        };\n        this.match = (pattern, consume = true, caseFold = false) => {\n            let token = null;\n            let match = null;\n            if (typeof pattern === 'string') {\n                const regex = new RegExp(pattern, caseFold ? 'i' : 'g');\n                match = regex.test(this._sourceText.substr(this._pos, pattern.length));\n                token = pattern;\n            }\n            else if (pattern instanceof RegExp) {\n                match = this._sourceText.slice(this._pos).match(pattern);\n                token = match && match[0];\n            }\n            if (match != null) {\n                if (typeof pattern === 'string' ||\n                    (match instanceof Array &&\n                        this._sourceText.startsWith(match[0], this._pos))) {\n                    if (consume) {\n                        this._start = this._pos;\n                        if (token && token.length) {\n                            this._pos += token.length;\n                        }\n                    }\n                    return match;\n                }\n            }\n            return false;\n        };\n        this.backUp = (num) => {\n            this._pos -= num;\n        };\n        this.column = () => this._pos;\n        this.indentation = () => {\n            const match = this._sourceText.match(/\\s*/);\n            let indent = 0;\n            if (match && match.length !== 0) {\n                const whitespaces = match[0];\n                let pos = 0;\n                while (whitespaces.length > pos) {\n                    if (whitespaces.charCodeAt(pos) === 9) {\n                        indent += 2;\n                    }\n                    else {\n                        indent++;\n                    }\n                    pos++;\n                }\n            }\n            return indent;\n        };\n        this.current = () => this._sourceText.slice(this._start, this._pos);\n        this._start = 0;\n        this._pos = 0;\n        this._sourceText = sourceText;\n    }\n    _testNextCharacter(pattern) {\n        const character = this._sourceText.charAt(this._pos);\n        let isMatched = false;\n        if (typeof pattern === 'string') {\n            isMatched = character === pattern;\n        }\n        else {\n            isMatched =\n                pattern instanceof RegExp\n                    ? pattern.test(character)\n                    : pattern(character);\n        }\n        return isMatched;\n    }\n}\n//# sourceMappingURL=CharacterStream.js.map","export function opt(ofRule) {\n    return { ofRule };\n}\nexport function list(ofRule, separator) {\n    return { ofRule, isList: true, separator };\n}\nexport function butNot(rule, exclusions) {\n    const ruleMatch = rule.match;\n    rule.match = token => {\n        let check = false;\n        if (ruleMatch) {\n            check = ruleMatch(token);\n        }\n        return (check &&\n            exclusions.every(exclusion => exclusion.match && !exclusion.match(token)));\n    };\n    return rule;\n}\nexport function t(kind, style) {\n    return { style, match: (token) => token.kind === kind };\n}\nexport function p(value, style) {\n    return {\n        style: style || 'punctuation',\n        match: (token) => token.kind === 'Punctuation' && token.value === value,\n    };\n}\n//# sourceMappingURL=RuleHelpers.js.map","import { opt, list, butNot, t, p } from './RuleHelpers';\nimport { Kind } from 'graphql';\nexport const isIgnored = (ch) => ch === ' ' ||\n    ch === '\\t' ||\n    ch === ',' ||\n    ch === '\\n' ||\n    ch === '\\r' ||\n    ch === '\\uFEFF' ||\n    ch === '\\u00A0';\nexport const LexRules = {\n    Name: /^[_A-Za-z][_0-9A-Za-z]*/,\n    Punctuation: /^(?:!|\\$|\\(|\\)|\\.\\.\\.|:|=|&|@|\\[|]|\\{|\\||\\})/,\n    Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,\n    String: /^(?:\"\"\"(?:\\\\\"\"\"|[^\"]|\"[^\"]|\"\"[^\"])*(?:\"\"\")?|\"(?:[^\"\\\\]|\\\\(?:\"|\\/|\\\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*\"?)/,\n    Comment: /^#.*/,\n};\nexport const ParseRules = {\n    Document: [list('Definition')],\n    Definition(token) {\n        switch (token.value) {\n            case '{':\n                return 'ShortQuery';\n            case 'query':\n                return 'Query';\n            case 'mutation':\n                return 'Mutation';\n            case 'subscription':\n                return 'Subscription';\n            case 'fragment':\n                return Kind.FRAGMENT_DEFINITION;\n            case 'schema':\n                return 'SchemaDef';\n            case 'scalar':\n                return 'ScalarDef';\n            case 'type':\n                return 'ObjectTypeDef';\n            case 'interface':\n                return 'InterfaceDef';\n            case 'union':\n                return 'UnionDef';\n            case 'enum':\n                return 'EnumDef';\n            case 'input':\n                return 'InputDef';\n            case 'extend':\n                return 'ExtendDef';\n            case 'directive':\n                return 'DirectiveDef';\n        }\n    },\n    ShortQuery: ['SelectionSet'],\n    Query: [\n        word('query'),\n        opt(name('def')),\n        opt('VariableDefinitions'),\n        list('Directive'),\n        'SelectionSet',\n    ],\n    Mutation: [\n        word('mutation'),\n        opt(name('def')),\n        opt('VariableDefinitions'),\n        list('Directive'),\n        'SelectionSet',\n    ],\n    Subscription: [\n        word('subscription'),\n        opt(name('def')),\n        opt('VariableDefinitions'),\n        list('Directive'),\n        'SelectionSet',\n    ],\n    VariableDefinitions: [p('('), list('VariableDefinition'), p(')')],\n    VariableDefinition: ['Variable', p(':'), 'Type', opt('DefaultValue')],\n    Variable: [p('$', 'variable'), name('variable')],\n    DefaultValue: [p('='), 'Value'],\n    SelectionSet: [p('{'), list('Selection'), p('}')],\n    Selection(token, stream) {\n        return token.value === '...'\n            ? stream.match(/[\\s\\u00a0,]*(on\\b|@|{)/, false)\n                ? 'InlineFragment'\n                : 'FragmentSpread'\n            : stream.match(/[\\s\\u00a0,]*:/, false)\n                ? 'AliasedField'\n                : 'Field';\n    },\n    AliasedField: [\n        name('property'),\n        p(':'),\n        name('qualifier'),\n        opt('Arguments'),\n        list('Directive'),\n        opt('SelectionSet'),\n    ],\n    Field: [\n        name('property'),\n        opt('Arguments'),\n        list('Directive'),\n        opt('SelectionSet'),\n    ],\n    Arguments: [p('('), list('Argument'), p(')')],\n    Argument: [name('attribute'), p(':'), 'Value'],\n    FragmentSpread: [p('...'), name('def'), list('Directive')],\n    InlineFragment: [\n        p('...'),\n        opt('TypeCondition'),\n        list('Directive'),\n        'SelectionSet',\n    ],\n    FragmentDefinition: [\n        word('fragment'),\n        opt(butNot(name('def'), [word('on')])),\n        'TypeCondition',\n        list('Directive'),\n        'SelectionSet',\n    ],\n    TypeCondition: [word('on'), 'NamedType'],\n    Value(token) {\n        switch (token.kind) {\n            case 'Number':\n                return 'NumberValue';\n            case 'String':\n                return 'StringValue';\n            case 'Punctuation':\n                switch (token.value) {\n                    case '[':\n                        return 'ListValue';\n                    case '{':\n                        return 'ObjectValue';\n                    case '$':\n                        return 'Variable';\n                    case '&':\n                        return 'NamedType';\n                }\n                return null;\n            case 'Name':\n                switch (token.value) {\n                    case 'true':\n                    case 'false':\n                        return 'BooleanValue';\n                }\n                if (token.value === 'null') {\n                    return 'NullValue';\n                }\n                return 'EnumValue';\n        }\n    },\n    NumberValue: [t('Number', 'number')],\n    StringValue: [\n        {\n            style: 'string',\n            match: token => token.kind === 'String',\n            update(state, token) {\n                if (token.value.startsWith('\"\"\"')) {\n                    state.inBlockstring = !token.value.slice(3).endsWith('\"\"\"');\n                }\n            },\n        },\n    ],\n    BooleanValue: [t('Name', 'builtin')],\n    NullValue: [t('Name', 'keyword')],\n    EnumValue: [name('string-2')],\n    ListValue: [p('['), list('Value'), p(']')],\n    ObjectValue: [p('{'), list('ObjectField'), p('}')],\n    ObjectField: [name('attribute'), p(':'), 'Value'],\n    Type(token) {\n        return token.value === '[' ? 'ListType' : 'NonNullType';\n    },\n    ListType: [p('['), 'Type', p(']'), opt(p('!'))],\n    NonNullType: ['NamedType', opt(p('!'))],\n    NamedType: [type('atom')],\n    Directive: [p('@', 'meta'), name('meta'), opt('Arguments')],\n    DirectiveDef: [\n        word('directive'),\n        p('@', 'meta'),\n        name('meta'),\n        opt('ArgumentsDef'),\n        word('on'),\n        list('DirectiveLocation', p('|')),\n    ],\n    InterfaceDef: [\n        word('interface'),\n        name('atom'),\n        opt('Implements'),\n        list('Directive'),\n        p('{'),\n        list('FieldDef'),\n        p('}'),\n    ],\n    Implements: [word('implements'), list('NamedType', p('&'))],\n    DirectiveLocation: [name('string-2')],\n    SchemaDef: [\n        word('schema'),\n        list('Directive'),\n        p('{'),\n        list('OperationTypeDef'),\n        p('}'),\n    ],\n    OperationTypeDef: [name('keyword'), p(':'), name('atom')],\n    ScalarDef: [word('scalar'), name('atom'), list('Directive')],\n    ObjectTypeDef: [\n        word('type'),\n        name('atom'),\n        opt('Implements'),\n        list('Directive'),\n        p('{'),\n        list('FieldDef'),\n        p('}'),\n    ],\n    FieldDef: [\n        name('property'),\n        opt('ArgumentsDef'),\n        p(':'),\n        'Type',\n        list('Directive'),\n    ],\n    ArgumentsDef: [p('('), list('InputValueDef'), p(')')],\n    InputValueDef: [\n        name('attribute'),\n        p(':'),\n        'Type',\n        opt('DefaultValue'),\n        list('Directive'),\n    ],\n    UnionDef: [\n        word('union'),\n        name('atom'),\n        list('Directive'),\n        p('='),\n        list('UnionMember', p('|')),\n    ],\n    UnionMember: ['NamedType'],\n    EnumDef: [\n        word('enum'),\n        name('atom'),\n        list('Directive'),\n        p('{'),\n        list('EnumValueDef'),\n        p('}'),\n    ],\n    EnumValueDef: [name('string-2'), list('Directive')],\n    InputDef: [\n        word('input'),\n        name('atom'),\n        list('Directive'),\n        p('{'),\n        list('InputValueDef'),\n        p('}'),\n    ],\n    ExtendDef: [word('extend'), 'ObjectTypeDef'],\n};\nfunction word(value) {\n    return {\n        style: 'keyword',\n        match: (token) => token.kind === 'Name' && token.value === value,\n    };\n}\nfunction name(style) {\n    return {\n        style,\n        match: (token) => token.kind === 'Name',\n        update(state, token) {\n            state.name = token.value;\n        },\n    };\n}\nfunction type(style) {\n    return {\n        style,\n        match: (token) => token.kind === 'Name',\n        update(state, token) {\n            if (state.prevState && state.prevState.prevState) {\n                state.name = token.value;\n                state.prevState.prevState.type = token.value;\n            }\n        },\n    };\n}\n//# sourceMappingURL=Rules.js.map","import { LexRules, ParseRules, isIgnored } from './Rules';\nimport { Kind } from 'graphql';\nexport default function onlineParser(options = {\n    eatWhitespace: stream => stream.eatWhile(isIgnored),\n    lexRules: LexRules,\n    parseRules: ParseRules,\n    editorConfig: {},\n}) {\n    return {\n        startState() {\n            const initialState = {\n                level: 0,\n                step: 0,\n                name: null,\n                kind: null,\n                type: null,\n                rule: null,\n                needsSeperator: false,\n                prevState: null,\n            };\n            pushRule(options.parseRules, initialState, Kind.DOCUMENT);\n            return initialState;\n        },\n        token(stream, state) {\n            return getToken(stream, state, options);\n        },\n    };\n}\nfunction getToken(stream, state, options) {\n    if (state.inBlockstring) {\n        if (stream.match(/.*\"\"\"/)) {\n            state.inBlockstring = false;\n            return 'string';\n        }\n        else {\n            stream.skipToEnd();\n            return 'string';\n        }\n    }\n    const { lexRules, parseRules, eatWhitespace, editorConfig } = options;\n    if (state.rule && state.rule.length === 0) {\n        popRule(state);\n    }\n    else if (state.needsAdvance) {\n        state.needsAdvance = false;\n        advanceRule(state, true);\n    }\n    if (stream.sol()) {\n        const tabSize = (editorConfig && editorConfig.tabSize) || 2;\n        state.indentLevel = Math.floor(stream.indentation() / tabSize);\n    }\n    if (eatWhitespace(stream)) {\n        return 'ws';\n    }\n    const token = lex(lexRules, stream);\n    if (!token) {\n        const matchedSomething = stream.match(/\\S+/);\n        if (!matchedSomething) {\n            stream.match(/\\s/);\n        }\n        pushRule(SpecialParseRules, state, 'Invalid');\n        return 'invalidchar';\n    }\n    if (token.kind === 'Comment') {\n        pushRule(SpecialParseRules, state, 'Comment');\n        return 'comment';\n    }\n    const backupState = assign({}, state);\n    if (token.kind === 'Punctuation') {\n        if (/^[{([]/.test(token.value)) {\n            if (state.indentLevel !== undefined) {\n                state.levels = (state.levels || []).concat(state.indentLevel + 1);\n            }\n        }\n        else if (/^[})\\]]/.test(token.value)) {\n            const levels = (state.levels = (state.levels || []).slice(0, -1));\n            if (state.indentLevel) {\n                if (levels.length > 0 &&\n                    levels[levels.length - 1] < state.indentLevel) {\n                    state.indentLevel = levels[levels.length - 1];\n                }\n            }\n        }\n    }\n    while (state.rule) {\n        let expected = typeof state.rule === 'function'\n            ? state.step === 0\n                ? state.rule(token, stream)\n                : null\n            : state.rule[state.step];\n        if (state.needsSeperator) {\n            expected = expected && (expected === null || expected === void 0 ? void 0 : expected.separator);\n        }\n        if (expected) {\n            if (expected.ofRule) {\n                expected = expected.ofRule;\n            }\n            if (typeof expected === 'string') {\n                pushRule(parseRules, state, expected);\n                continue;\n            }\n            if (expected.match && expected.match(token)) {\n                if (expected.update) {\n                    expected.update(state, token);\n                }\n                if (token.kind === 'Punctuation') {\n                    advanceRule(state, true);\n                }\n                else {\n                    state.needsAdvance = true;\n                }\n                return expected.style;\n            }\n        }\n        unsuccessful(state);\n    }\n    assign(state, backupState);\n    pushRule(SpecialParseRules, state, 'Invalid');\n    return 'invalidchar';\n}\nfunction assign(to, from) {\n    const keys = Object.keys(from);\n    for (let i = 0; i < keys.length; i++) {\n        to[keys[i]] = from[keys[i]];\n    }\n    return to;\n}\nconst SpecialParseRules = {\n    Invalid: [],\n    Comment: [],\n};\nfunction pushRule(rules, state, ruleKind) {\n    if (!rules[ruleKind]) {\n        throw new TypeError('Unknown rule: ' + ruleKind);\n    }\n    state.prevState = Object.assign({}, state);\n    state.kind = ruleKind;\n    state.name = null;\n    state.type = null;\n    state.rule = rules[ruleKind];\n    state.step = 0;\n    state.needsSeperator = false;\n}\nfunction popRule(state) {\n    if (!state.prevState) {\n        return;\n    }\n    state.kind = state.prevState.kind;\n    state.name = state.prevState.name;\n    state.type = state.prevState.type;\n    state.rule = state.prevState.rule;\n    state.step = state.prevState.step;\n    state.needsSeperator = state.prevState.needsSeperator;\n    state.prevState = state.prevState.prevState;\n}\nfunction advanceRule(state, successful) {\n    if (isList(state) && state.rule) {\n        const step = state.rule[state.step];\n        if (step.separator) {\n            const separator = step.separator;\n            state.needsSeperator = !state.needsSeperator;\n            if (!state.needsSeperator && separator.ofRule) {\n                return;\n            }\n        }\n        if (successful) {\n            return;\n        }\n    }\n    state.needsSeperator = false;\n    state.step++;\n    while (state.rule &&\n        !(Array.isArray(state.rule) && state.step < state.rule.length)) {\n        popRule(state);\n        if (state.rule) {\n            if (isList(state)) {\n                if (state.rule && state.rule[state.step].separator) {\n                    state.needsSeperator = !state.needsSeperator;\n                }\n            }\n            else {\n                state.needsSeperator = false;\n                state.step++;\n            }\n        }\n    }\n}\nfunction isList(state) {\n    const step = Array.isArray(state.rule) &&\n        typeof state.rule[state.step] !== 'string' &&\n        state.rule[state.step];\n    return step && step.isList;\n}\nfunction unsuccessful(state) {\n    while (state.rule &&\n        !(Array.isArray(state.rule) && state.rule[state.step].ofRule)) {\n        popRule(state);\n    }\n    if (state.rule) {\n        advanceRule(state, false);\n    }\n}\nfunction lex(lexRules, stream) {\n    const kinds = Object.keys(lexRules);\n    for (let i = 0; i < kinds.length; i++) {\n        const match = stream.match(lexRules[kinds[i]]);\n        if (match && match instanceof Array) {\n            return { kind: kinds[i], value: match[0] };\n        }\n    }\n}\n//# sourceMappingURL=onlineParser.js.map","import { Kind } from 'graphql';\nexport const AdditionalRuleKinds = {\n    ALIASED_FIELD: 'AliasedField',\n    ARGUMENTS: 'Arguments',\n    SHORT_QUERY: 'ShortQuery',\n    QUERY: 'Query',\n    MUTATION: 'Mutation',\n    SUBSCRIPTION: 'Subscription',\n    TYPE_CONDITION: 'TypeCondition',\n    INVALID: 'Invalid',\n    COMMENT: 'Comment',\n    SCHEMA_DEF: 'SchemaDef',\n    SCALAR_DEF: 'ScalarDef',\n    OBJECT_TYPE_DEF: 'ObjectTypeDef',\n    OBJECT_VALUE: 'ObjectValue',\n    LIST_VALUE: 'ListValue',\n    INTERFACE_DEF: 'InterfaceDef',\n    UNION_DEF: 'UnionDef',\n    ENUM_DEF: 'EnumDef',\n    ENUM_VALUE: 'EnumValue',\n    FIELD_DEF: 'FieldDef',\n    INPUT_DEF: 'InputDef',\n    INPUT_VALUE_DEF: 'InputValueDef',\n    ARGUMENTS_DEF: 'ArgumentsDef',\n    EXTEND_DEF: 'ExtendDef',\n    DIRECTIVE_DEF: 'DirectiveDef',\n    IMPLEMENTS: 'Implements',\n    VARIABLE_DEFINITIONS: 'VariableDefinitions',\n    TYPE: 'Type',\n};\nexport const RuleKinds = Object.assign(Object.assign({}, Kind), AdditionalRuleKinds);\n//# sourceMappingURL=types.js.map","export { default as CharacterStream } from './CharacterStream';\nexport { LexRules, ParseRules, isIgnored } from './Rules';\nexport { butNot, list, opt, p, t } from './RuleHelpers';\nexport { default as onlineParser } from './onlineParser';\nexport * from './types';\n//# sourceMappingURL=index.js.map"],"names":[],"sourceRoot":""}