{"version":3,"sources":["webpack:///./node_modules/graphql/language/blockString.mjs","webpack:///./node_modules/graphql/jsutils/devAssert.mjs","webpack:///./node_modules/graphql/jsutils/defineToJSON.mjs","webpack:///./node_modules/graphql/jsutils/isObjectLike.mjs","webpack:///./node_modules/graphql/language/location.mjs","webpack:///./node_modules/graphql/language/printLocation.mjs","webpack:///./node_modules/graphql/error/GraphQLError.mjs","webpack:///./node_modules/graphql/error/syntaxError.mjs","webpack:///./node_modules/graphql/language/kinds.mjs","webpack:///./node_modules/graphql/jsutils/defineToStringTag.mjs","webpack:///./node_modules/graphql/language/source.mjs","webpack:///./node_modules/graphql/language/tokenKind.mjs","webpack:///./node_modules/graphql/language/lexer.mjs","webpack:///./node_modules/graphql/language/directiveLocation.mjs","webpack:///./node_modules/graphql/language/parser.mjs","webpack:///./node_modules/graphql/language/visitor.mjs","webpack:///./node_modules/graphql/jsutils/nodejsCustomInspectSymbol.mjs","webpack:///./node_modules/graphql/language/printer.mjs","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/graphql-tag/src/index.js","webpack:///./node_modules/graphql/jsutils/inspect.mjs","webpack:///./node_modules/hammerjs/hammer.js","webpack:///./node_modules/isarray/index.js"],"names":["dedentBlockStringValue","rawString","lines","split","commonIndent","getBlockStringIndentation","i","length","slice","isBlank","shift","pop","join","line","indent","leadingWhitespace","str","printBlockString","value","indentation","arguments","undefined","preferMultipleLines","isSingleLine","indexOf","hasLeadingSpace","hasTrailingQuote","printAsMultipleLines","result","replace","devAssert","condition","message","booleanCondition","Boolean","Error","defineToJSON","classObject","fn","prototype","toString","toJSON","inspect","nodejsCustomInspectSymbol","_typeof","obj","Symbol","iterator","constructor","isObjectLike","getLocation","source","position","match","lineRegexp","column","exec","body","index","printLocation","location","printSourceLocation","start","sourceLocation","firstLineColumnOffset","locationOffset","whitespace","lineIndex","lineOffset","lineNum","columnOffset","columnNum","locationStr","concat","name","locationLine","sublineIndex","Math","floor","sublineColumnNum","sublines","push","printPrefixedLines","map","subline","existingLines","filter","_ref","padLen","max","apply","_ref2","prefix","_ref3","lpad","len","Array","GraphQLError","nodes","positions","path","originalError","extensions","_nodes","isArray","_source","node","loc","_locations","_positions","reduce","list","pos","_extensions","originalExtensions","Object","defineProperties","this","enumerable","writable","locations","stack","defineProperty","configurable","captureStackTrace","printError","error","output","_i2","_error$nodes2","_i4","_error$locations2","syntaxError","description","create","Kind","freeze","NAME","DOCUMENT","OPERATION_DEFINITION","VARIABLE_DEFINITION","SELECTION_SET","FIELD","ARGUMENT","FRAGMENT_SPREAD","INLINE_FRAGMENT","FRAGMENT_DEFINITION","VARIABLE","INT","FLOAT","STRING","BOOLEAN","NULL","ENUM","LIST","OBJECT","OBJECT_FIELD","DIRECTIVE","NAMED_TYPE","LIST_TYPE","NON_NULL_TYPE","SCHEMA_DEFINITION","OPERATION_TYPE_DEFINITION","SCALAR_TYPE_DEFINITION","OBJECT_TYPE_DEFINITION","FIELD_DEFINITION","INPUT_VALUE_DEFINITION","INTERFACE_TYPE_DEFINITION","UNION_TYPE_DEFINITION","ENUM_TYPE_DEFINITION","ENUM_VALUE_DEFINITION","INPUT_OBJECT_TYPE_DEFINITION","DIRECTIVE_DEFINITION","SCHEMA_EXTENSION","SCALAR_TYPE_EXTENSION","OBJECT_TYPE_EXTENSION","INTERFACE_TYPE_EXTENSION","UNION_TYPE_EXTENSION","ENUM_TYPE_EXTENSION","INPUT_OBJECT_TYPE_EXTENSION","defineToStringTag","toStringTag","get","TokenKind","SOF","EOF","BANG","DOLLAR","AMP","PAREN_L","PAREN_R","SPREAD","COLON","EQUALS","AT","BRACKET_L","BRACKET_R","BRACE_L","PIPE","BRACE_R","BLOCK_STRING","COMMENT","createLexer","options","startOfFileToken","Tok","lexer","lastToken","token","lineStart","advance","advanceLexer","lookahead","kind","next","readToken","end","prev","printCharCode","code","isNaN","JSON","stringify","String","fromCharCode","toUpperCase","bodyLength","positionAfterWhitespace","col","charCodeAt","readComment","readName","readNumber","readBlockString","readString","unexpectedCharacterMessage","startPosition","firstCode","isFloat","readDigits","chunkStart","charCode","uniCharCode","invalidSequence","rawValue","a","b","c","d","char2hex","DirectiveLocation","QUERY","MUTATION","SUBSCRIPTION","SCHEMA","SCALAR","ARGUMENT_DEFINITION","INTERFACE","UNION","ENUM_VALUE","INPUT_OBJECT","INPUT_FIELD_DEFINITION","parse","parser","parseDocument","parseValue","expectToken","parseValueLiteral","parseType","type","parseTypeReference","Parser","sourceObj","_lexer","_options","_proto","parseName","definitions","many","parseDefinition","peek","parseOperationDefinition","parseFragmentDefinition","parseTypeSystemDefinition","parseTypeSystemExtension","peekDescription","unexpected","operation","variableDefinitions","directives","selectionSet","parseSelectionSet","parseOperationType","parseVariableDefinitions","parseDirectives","operationToken","optionalMany","parseVariableDefinition","variable","parseVariable","defaultValue","expectOptionalToken","selections","parseSelection","parseFragment","parseField","alias","nameOrAlias","parseArguments","isConst","item","parseConstArgument","parseArgument","hasTypeCondition","expectOptionalKeyword","parseFragmentName","typeCondition","parseNamedType","expectKeyword","experimentalFragmentVariables","parseList","parseObject","parseStringLiteral","block","_this","values","any","_this2","parseObjectField","fields","parseDirective","keywordToken","parseSchemaDefinition","parseScalarTypeDefinition","parseObjectTypeDefinition","parseInterfaceTypeDefinition","parseUnionTypeDefinition","parseEnumTypeDefinition","parseInputObjectTypeDefinition","parseDirectiveDefinition","parseDescription","operationTypes","parseOperationTypeDefinition","interfaces","parseImplementsInterfaces","parseFieldsDefinition","types","allowLegacySDLImplementsInterfaces","allowLegacySDLEmptyFields","parseFieldDefinition","args","parseArgumentDefs","parseInputValueDef","parseUnionMemberTypes","parseEnumValuesDefinition","parseEnumValueDefinition","parseInputFieldsDefinition","parseSchemaExtension","parseScalarTypeExtension","parseObjectTypeExtension","parseInterfaceTypeExtension","parseUnionTypeExtension","parseEnumTypeExtension","parseInputObjectTypeExtension","repeatable","parseDirectiveLocations","parseDirectiveLocation","startToken","noLocation","Loc","getTokenDesc","atToken","openKind","parseFn","closeKind","call","endToken","QueryDocumentKeys","Name","Document","OperationDefinition","VariableDefinition","Variable","SelectionSet","Field","Argument","FragmentSpread","InlineFragment","FragmentDefinition","IntValue","FloatValue","StringValue","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","Directive","NamedType","ListType","NonNullType","SchemaDefinition","OperationTypeDefinition","ScalarTypeDefinition","ObjectTypeDefinition","FieldDefinition","InputValueDefinition","InterfaceTypeDefinition","UnionTypeDefinition","EnumTypeDefinition","EnumValueDefinition","InputObjectTypeDefinition","DirectiveDefinition","SchemaExtension","ScalarTypeExtension","ObjectTypeExtension","InterfaceTypeExtension","UnionTypeExtension","EnumTypeExtension","InputObjectTypeExtension","BREAK","visit","root","visitor","visitorKeys","inArray","keys","edits","key","parent","ancestors","newRoot","isLeaving","isEdited","clone","_Object$keys2","k","editOffset","ii","editKey","editValue","splice","isNode","visitFn","getVisitFn","maybeNode","kindVisitor","kindSpecificVisitor","leave","enter","specificVisitor","specificKindVisitor","for","print","ast","printDocASTReducer","op","varDefs","wrap","_ref4","_ref5","_ref6","_ref7","_ref8","_ref9","_ref10","isBlockString","_ref11","_ref12","_ref13","_ref14","_ref15","_ref16","_ref17","_ref18","_ref19","_ref20","_ref21","addDescription","_ref22","_ref23","_ref24","hasMultilineItems","_ref25","_ref26","_ref27","_ref28","_ref29","_ref30","_ref31","_ref32","_ref33","_ref34","_ref35","_ref36","_ref37","_ref38","cb","maybeArray","separator","x","array","maybeString","isMultiline","string","some","exports","read","buffer","offset","isLE","mLen","nBytes","e","m","eLen","eMax","eBias","nBits","s","NaN","Infinity","pow","write","rt","abs","log","LN2","normalize","trim","docCache","fragmentSourceMap","cacheKeyFromLoc","substring","resetCaches","printFragmentWarnings","processFragments","astFragmentMap","fragmentDefinition","fragmentName","sourceKey","hasOwnProperty","console","warn","disableFragmentWarnings","stripLoc","doc","removeLocAtThisLevel","docType","valueType","cacheKey","parsed","enableExperimentalFragmentVariables","disableExperimentalFragmentVariables","gql","literals","default","module","MAX_ARRAY_LENGTH","MAX_RECURSIVE_DEPTH","formatValue","seenValues","formatObjectValue","previouslySeenValues","customInspectFn","getCustomFn","customValue","formatArray","formatObject","object","getObjectTag","properties","min","remaining","items","tag","window","document","exportName","assign","VENDOR_PREFIXES","TEST_ELEMENT","createElement","TYPE_FUNCTION","round","now","Date","setTimeoutContext","timeout","context","setTimeout","bindFn","invokeArrayArg","arg","each","forEach","deprecate","method","deprecationMessage","target","TypeError","nextKey","extend","dest","src","merge","inherit","child","base","childP","baseP","_super","boolOrFn","val","ifUndefined","val1","val2","addEventListeners","handler","splitStr","addEventListener","removeEventListeners","removeEventListener","hasParent","parentNode","inStr","find","findByKey","toArray","uniqueArray","sort","results","prefixed","property","prop","camelProp","_uniqueId","uniqueId","getWindowForElement","element","ownerDocument","defaultView","parentWindow","MOBILE_REGEX","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","test","navigator","userAgent","INPUT_TYPE_TOUCH","INPUT_TYPE_PEN","INPUT_TYPE_MOUSE","INPUT_TYPE_KINECT","COMPUTE_INTERVAL","INPUT_START","INPUT_MOVE","INPUT_END","INPUT_CANCEL","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_HORIZONTAL","DIRECTION_VERTICAL","DIRECTION_ALL","PROPS_XY","PROPS_CLIENT_XY","Input","manager","callback","self","inputTarget","domHandler","ev","enable","init","createInputInstance","Type","inputClass","PointerEventInput","TouchInput","TouchMouseInput","MouseInput","inputHandler","eventType","input","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","computeInputData","emit","recognize","prevInput","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","computeDeltaXY","offsetDirection","getDirection","deltaX","deltaY","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","y","scale","getScale","rotation","getRotation","maxPointers","computeIntervalInputData","srcEvent","offsetDelta","prevDelta","velocity","velocityX","velocityY","direction","last","lastInterval","v","clientX","clientY","p1","p2","props","sqrt","atan2","PI","evEl","evTarget","evWin","destroy","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","pressed","button","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","2","3","4","5","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","toLowerCase","isTouch","storeIndex","pointerId","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SINGLE_TOUCH_TARGET_EVENTS","SINGLE_TOUCH_WINDOW_EVENTS","SingleTouchInput","started","normalizeSingleTouches","all","touches","changed","changedTouches","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","touch","DEDUP_TIMEOUT","DEDUP_DISTANCE","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","removeLastTouch","isSyntheticEvent","t","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","style","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_AUTO","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","getTouchActionProps","TouchAction","set","cleanTouchActions","actions","hasPanX","hasPanY","touchMap","cssSupports","CSS","supports","compute","update","touchAction","recognizers","recognizer","getTouchAction","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","STATE_FAILED","Recognizer","defaults","id","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","preset","Manager","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","event","additionalEvent","tryEmit","canEmit","inputDataClone","reset","process","attrTest","optionPointers","isRecognized","isValid","threshold","directionTest","hasMoved","inOut","time","validPointers","validMovement","validTime","clearTimeout","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","STOP","FORCED_STOP","handlers","oldCssProps","toggleCssProps","add","triggerDomEvent","data","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","stop","force","stopped","curRecognizer","existing","remove","on","events","off","Tap","Pan","Swipe","Pinch","Rotate","Press","freeGlobal","arr"],"mappings":"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","file":"js/chunk-vendors~73914085.8d91159e.js","sourcesContent":["/**\n * Produces the value of a block string from its parsed raw value, similar to\n * CoffeeScript's block string, Python's docstring trim or Ruby's strip_heredoc.\n *\n * This implements the GraphQL spec's BlockStringValue() static algorithm.\n */\nexport function dedentBlockStringValue(rawString) {\n  // Expand a block string's raw value into independent lines.\n  var lines = rawString.split(/\\r\\n|[\\n\\r]/g); // Remove common indentation from all lines but first.\n\n  var commonIndent = getBlockStringIndentation(lines);\n\n  if (commonIndent !== 0) {\n    for (var i = 1; i < lines.length; i++) {\n      lines[i] = lines[i].slice(commonIndent);\n    }\n  } // Remove leading and trailing blank lines.\n\n\n  while (lines.length > 0 && isBlank(lines[0])) {\n    lines.shift();\n  }\n\n  while (lines.length > 0 && isBlank(lines[lines.length - 1])) {\n    lines.pop();\n  } // Return a string of the lines joined with U+000A.\n\n\n  return lines.join('\\n');\n} // @internal\n\nexport function getBlockStringIndentation(lines) {\n  var commonIndent = null;\n\n  for (var i = 1; i < lines.length; i++) {\n    var line = lines[i];\n    var indent = leadingWhitespace(line);\n\n    if (indent === line.length) {\n      continue; // skip empty lines\n    }\n\n    if (commonIndent === null || indent < commonIndent) {\n      commonIndent = indent;\n\n      if (commonIndent === 0) {\n        break;\n      }\n    }\n  }\n\n  return commonIndent === null ? 0 : commonIndent;\n}\n\nfunction leadingWhitespace(str) {\n  var i = 0;\n\n  while (i < str.length && (str[i] === ' ' || str[i] === '\\t')) {\n    i++;\n  }\n\n  return i;\n}\n\nfunction isBlank(str) {\n  return leadingWhitespace(str) === str.length;\n}\n/**\n * Print a block string in the indented block form by adding a leading and\n * trailing blank line. However, if a block string starts with whitespace and is\n * a single-line, adding a leading blank line would strip that whitespace.\n */\n\n\nexport function printBlockString(value) {\n  var indentation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n  var preferMultipleLines = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  var isSingleLine = value.indexOf('\\n') === -1;\n  var hasLeadingSpace = value[0] === ' ' || value[0] === '\\t';\n  var hasTrailingQuote = value[value.length - 1] === '\"';\n  var printAsMultipleLines = !isSingleLine || hasTrailingQuote || preferMultipleLines;\n  var result = ''; // Format a multi-line block quote to account for leading space.\n\n  if (printAsMultipleLines && !(isSingleLine && hasLeadingSpace)) {\n    result += '\\n' + indentation;\n  }\n\n  result += indentation ? value.replace(/\\n/g, '\\n' + indentation) : value;\n\n  if (printAsMultipleLines) {\n    result += '\\n';\n  }\n\n  return '\"\"\"' + result.replace(/\"\"\"/g, '\\\\\"\"\"') + '\"\"\"';\n}\n","export default function devAssert(condition, message) {\n  var booleanCondition = Boolean(condition);\n\n  if (!booleanCondition) {\n    throw new Error(message);\n  }\n}\n","import nodejsCustomInspectSymbol from './nodejsCustomInspectSymbol';\n/**\n * The `defineToJSON()` function defines toJSON() and inspect() prototype\n * methods, if no function provided they become aliases for toString().\n */\n\nexport default function defineToJSON(classObject) {\n  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : classObject.prototype.toString;\n  classObject.prototype.toJSON = fn;\n  classObject.prototype.inspect = fn;\n\n  if (nodejsCustomInspectSymbol) {\n    classObject.prototype[nodejsCustomInspectSymbol] = fn;\n  }\n}\n","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/**\n * Return true if `value` is object-like. A value is object-like if it's not\n * `null` and has a `typeof` result of \"object\".\n */\nexport default function isObjectLike(value) {\n  return _typeof(value) == 'object' && value !== null;\n}\n","/**\n * Represents a location in a Source.\n */\n\n/**\n * Takes a Source and a UTF-8 character offset, and returns the corresponding\n * line and column as a SourceLocation.\n */\nexport function getLocation(source, position) {\n  var lineRegexp = /\\r\\n|[\\n\\r]/g;\n  var line = 1;\n  var column = position + 1;\n  var match;\n\n  while ((match = lineRegexp.exec(source.body)) && match.index < position) {\n    line += 1;\n    column = position + 1 - (match.index + match[0].length);\n  }\n\n  return {\n    line: line,\n    column: column\n  };\n}\n","import { getLocation } from '../language/location';\n/**\n * Render a helpful description of the location in the GraphQL Source document.\n */\n\nexport function printLocation(location) {\n  return printSourceLocation(location.source, getLocation(location.source, location.start));\n}\n/**\n * Render a helpful description of the location in the GraphQL Source document.\n */\n\nexport function printSourceLocation(source, sourceLocation) {\n  var firstLineColumnOffset = source.locationOffset.column - 1;\n  var body = whitespace(firstLineColumnOffset) + source.body;\n  var lineIndex = sourceLocation.line - 1;\n  var lineOffset = source.locationOffset.line - 1;\n  var lineNum = sourceLocation.line + lineOffset;\n  var columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;\n  var columnNum = sourceLocation.column + columnOffset;\n  var locationStr = \"\".concat(source.name, \":\").concat(lineNum, \":\").concat(columnNum, \"\\n\");\n  var lines = body.split(/\\r\\n|[\\n\\r]/g);\n  var locationLine = lines[lineIndex]; // Special case for minified documents\n\n  if (locationLine.length > 120) {\n    var sublineIndex = Math.floor(columnNum / 80);\n    var sublineColumnNum = columnNum % 80;\n    var sublines = [];\n\n    for (var i = 0; i < locationLine.length; i += 80) {\n      sublines.push(locationLine.slice(i, i + 80));\n    }\n\n    return locationStr + printPrefixedLines([[\"\".concat(lineNum), sublines[0]]].concat(sublines.slice(1, sublineIndex + 1).map(function (subline) {\n      return ['', subline];\n    }), [[' ', whitespace(sublineColumnNum - 1) + '^'], ['', sublines[sublineIndex + 1]]]));\n  }\n\n  return locationStr + printPrefixedLines([// Lines specified like this: [\"prefix\", \"string\"],\n  [\"\".concat(lineNum - 1), lines[lineIndex - 1]], [\"\".concat(lineNum), locationLine], ['', whitespace(columnNum - 1) + '^'], [\"\".concat(lineNum + 1), lines[lineIndex + 1]]]);\n}\n\nfunction printPrefixedLines(lines) {\n  var existingLines = lines.filter(function (_ref) {\n    var _ = _ref[0],\n        line = _ref[1];\n    return line !== undefined;\n  });\n  var padLen = Math.max.apply(Math, existingLines.map(function (_ref2) {\n    var prefix = _ref2[0];\n    return prefix.length;\n  }));\n  return existingLines.map(function (_ref3) {\n    var prefix = _ref3[0],\n        line = _ref3[1];\n    return lpad(padLen, prefix) + (line ? ' | ' + line : ' |');\n  }).join('\\n');\n}\n\nfunction whitespace(len) {\n  return Array(len + 1).join(' ');\n}\n\nfunction lpad(len, str) {\n  return whitespace(len - str.length) + str;\n}\n","import isObjectLike from '../jsutils/isObjectLike';\nimport { getLocation } from '../language/location';\nimport { printLocation, printSourceLocation } from '../language/printLocation';\n/**\n * A GraphQLError describes an Error found during the parse, validate, or\n * execute phases of performing a GraphQL operation. In addition to a message\n * and stack trace, it also includes information about the locations in a\n * GraphQL document and/or execution result that correspond to the Error.\n */\n\nexport function GraphQLError( // eslint-disable-line no-redeclare\nmessage, nodes, source, positions, path, originalError, extensions) {\n  // Compute list of blame nodes.\n  var _nodes = Array.isArray(nodes) ? nodes.length !== 0 ? nodes : undefined : nodes ? [nodes] : undefined; // Compute locations in the source for the given nodes/positions.\n\n\n  var _source = source;\n\n  if (!_source && _nodes) {\n    var node = _nodes[0];\n    _source = node && node.loc && node.loc.source;\n  }\n\n  var _positions = positions;\n\n  if (!_positions && _nodes) {\n    _positions = _nodes.reduce(function (list, node) {\n      if (node.loc) {\n        list.push(node.loc.start);\n      }\n\n      return list;\n    }, []);\n  }\n\n  if (_positions && _positions.length === 0) {\n    _positions = undefined;\n  }\n\n  var _locations;\n\n  if (positions && source) {\n    _locations = positions.map(function (pos) {\n      return getLocation(source, pos);\n    });\n  } else if (_nodes) {\n    _locations = _nodes.reduce(function (list, node) {\n      if (node.loc) {\n        list.push(getLocation(node.loc.source, node.loc.start));\n      }\n\n      return list;\n    }, []);\n  }\n\n  var _extensions = extensions;\n\n  if (_extensions == null && originalError != null) {\n    var originalExtensions = originalError.extensions;\n\n    if (isObjectLike(originalExtensions)) {\n      _extensions = originalExtensions;\n    }\n  }\n\n  Object.defineProperties(this, {\n    message: {\n      value: message,\n      // By being enumerable, JSON.stringify will include `message` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: true,\n      writable: true\n    },\n    locations: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: _locations || undefined,\n      // By being enumerable, JSON.stringify will include `locations` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(_locations)\n    },\n    path: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: path || undefined,\n      // By being enumerable, JSON.stringify will include `path` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(path)\n    },\n    nodes: {\n      value: _nodes || undefined\n    },\n    source: {\n      value: _source || undefined\n    },\n    positions: {\n      value: _positions || undefined\n    },\n    originalError: {\n      value: originalError\n    },\n    extensions: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: _extensions || undefined,\n      // By being enumerable, JSON.stringify will include `path` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(_extensions)\n    }\n  }); // Include (non-enumerable) stack trace.\n\n  if (originalError && originalError.stack) {\n    Object.defineProperty(this, 'stack', {\n      value: originalError.stack,\n      writable: true,\n      configurable: true\n    });\n  } else if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, GraphQLError);\n  } else {\n    Object.defineProperty(this, 'stack', {\n      value: Error().stack,\n      writable: true,\n      configurable: true\n    });\n  }\n}\nGraphQLError.prototype = Object.create(Error.prototype, {\n  constructor: {\n    value: GraphQLError\n  },\n  name: {\n    value: 'GraphQLError'\n  },\n  toString: {\n    value: function toString() {\n      return printError(this);\n    }\n  }\n});\n/**\n * Prints a GraphQLError to a string, representing useful location information\n * about the error's position in the source.\n */\n\nexport function printError(error) {\n  var output = error.message;\n\n  if (error.nodes) {\n    for (var _i2 = 0, _error$nodes2 = error.nodes; _i2 < _error$nodes2.length; _i2++) {\n      var node = _error$nodes2[_i2];\n\n      if (node.loc) {\n        output += '\\n\\n' + printLocation(node.loc);\n      }\n    }\n  } else if (error.source && error.locations) {\n    for (var _i4 = 0, _error$locations2 = error.locations; _i4 < _error$locations2.length; _i4++) {\n      var location = _error$locations2[_i4];\n      output += '\\n\\n' + printSourceLocation(error.source, location);\n    }\n  }\n\n  return output;\n}\n","import { GraphQLError } from './GraphQLError';\n/**\n * Produces a GraphQLError representing a syntax error, containing useful\n * descriptive information about the syntax error's position in the source.\n */\n\nexport function syntaxError(source, position, description) {\n  return new GraphQLError(\"Syntax Error: \".concat(description), undefined, source, [position]);\n}\n","/**\n * The set of allowed kind values for AST nodes.\n */\nexport var Kind = Object.freeze({\n  // Name\n  NAME: 'Name',\n  // Document\n  DOCUMENT: 'Document',\n  OPERATION_DEFINITION: 'OperationDefinition',\n  VARIABLE_DEFINITION: 'VariableDefinition',\n  SELECTION_SET: 'SelectionSet',\n  FIELD: 'Field',\n  ARGUMENT: 'Argument',\n  // Fragments\n  FRAGMENT_SPREAD: 'FragmentSpread',\n  INLINE_FRAGMENT: 'InlineFragment',\n  FRAGMENT_DEFINITION: 'FragmentDefinition',\n  // Values\n  VARIABLE: 'Variable',\n  INT: 'IntValue',\n  FLOAT: 'FloatValue',\n  STRING: 'StringValue',\n  BOOLEAN: 'BooleanValue',\n  NULL: 'NullValue',\n  ENUM: 'EnumValue',\n  LIST: 'ListValue',\n  OBJECT: 'ObjectValue',\n  OBJECT_FIELD: 'ObjectField',\n  // Directives\n  DIRECTIVE: 'Directive',\n  // Types\n  NAMED_TYPE: 'NamedType',\n  LIST_TYPE: 'ListType',\n  NON_NULL_TYPE: 'NonNullType',\n  // Type System Definitions\n  SCHEMA_DEFINITION: 'SchemaDefinition',\n  OPERATION_TYPE_DEFINITION: 'OperationTypeDefinition',\n  // Type Definitions\n  SCALAR_TYPE_DEFINITION: 'ScalarTypeDefinition',\n  OBJECT_TYPE_DEFINITION: 'ObjectTypeDefinition',\n  FIELD_DEFINITION: 'FieldDefinition',\n  INPUT_VALUE_DEFINITION: 'InputValueDefinition',\n  INTERFACE_TYPE_DEFINITION: 'InterfaceTypeDefinition',\n  UNION_TYPE_DEFINITION: 'UnionTypeDefinition',\n  ENUM_TYPE_DEFINITION: 'EnumTypeDefinition',\n  ENUM_VALUE_DEFINITION: 'EnumValueDefinition',\n  INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',\n  // Directive Definitions\n  DIRECTIVE_DEFINITION: 'DirectiveDefinition',\n  // Type System Extensions\n  SCHEMA_EXTENSION: 'SchemaExtension',\n  // Type Extensions\n  SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',\n  OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',\n  INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',\n  UNION_TYPE_EXTENSION: 'UnionTypeExtension',\n  ENUM_TYPE_EXTENSION: 'EnumTypeExtension',\n  INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension'\n});\n/**\n * The enum type representing the possible kind values of AST nodes.\n */\n","/**\n * The `defineToStringTag()` function checks first to see if the runtime\n * supports the `Symbol` class and then if the `Symbol.toStringTag` constant\n * is defined as a `Symbol` instance. If both conditions are met, the\n * Symbol.toStringTag property is defined as a getter that returns the\n * supplied class constructor's name.\n *\n * @method defineToStringTag\n *\n * @param {Class<any>} classObject a class such as Object, String, Number but\n * typically one of your own creation through the class keyword; `class A {}`,\n * for example.\n */\nexport default function defineToStringTag(classObject) {\n  if (typeof Symbol === 'function' && Symbol.toStringTag) {\n    Object.defineProperty(classObject.prototype, Symbol.toStringTag, {\n      get: function get() {\n        return this.constructor.name;\n      }\n    });\n  }\n}\n","import devAssert from '../jsutils/devAssert';\nimport defineToStringTag from '../jsutils/defineToStringTag';\n\n/**\n * A representation of source input to GraphQL.\n * `name` and `locationOffset` are optional. They are useful for clients who\n * store GraphQL documents in source files; for example, if the GraphQL input\n * starts at line 40 in a file named Foo.graphql, it might be useful for name to\n * be \"Foo.graphql\" and location to be `{ line: 40, column: 0 }`.\n * line and column in locationOffset are 1-indexed\n */\nexport var Source = function Source(body, name, locationOffset) {\n  this.body = body;\n  this.name = name || 'GraphQL request';\n  this.locationOffset = locationOffset || {\n    line: 1,\n    column: 1\n  };\n  this.locationOffset.line > 0 || devAssert(0, 'line in locationOffset is 1-indexed and must be positive');\n  this.locationOffset.column > 0 || devAssert(0, 'column in locationOffset is 1-indexed and must be positive');\n}; // Conditionally apply `[Symbol.toStringTag]` if `Symbol`s are supported\n\ndefineToStringTag(Source);\n","/**\n * An exported enum describing the different kinds of tokens that the\n * lexer emits.\n */\nexport var TokenKind = Object.freeze({\n  SOF: '<SOF>',\n  EOF: '<EOF>',\n  BANG: '!',\n  DOLLAR: '$',\n  AMP: '&',\n  PAREN_L: '(',\n  PAREN_R: ')',\n  SPREAD: '...',\n  COLON: ':',\n  EQUALS: '=',\n  AT: '@',\n  BRACKET_L: '[',\n  BRACKET_R: ']',\n  BRACE_L: '{',\n  PIPE: '|',\n  BRACE_R: '}',\n  NAME: 'Name',\n  INT: 'Int',\n  FLOAT: 'Float',\n  STRING: 'String',\n  BLOCK_STRING: 'BlockString',\n  COMMENT: 'Comment'\n});\n/**\n * The enum type representing the token kinds values.\n */\n","import defineToJSON from '../jsutils/defineToJSON';\nimport { syntaxError } from '../error/syntaxError';\nimport { dedentBlockStringValue } from './blockString';\nimport { TokenKind } from './tokenKind';\n/**\n * Given a Source object, this returns a Lexer for that source.\n * A Lexer is a stateful stream generator in that every time\n * it is advanced, it returns the next token in the Source. Assuming the\n * source lexes, the final Token emitted by the lexer will be of kind\n * EOF, after which the lexer will repeatedly return the same EOF token\n * whenever called.\n */\n\nexport function createLexer(source, options) {\n  var startOfFileToken = new Tok(TokenKind.SOF, 0, 0, 0, 0, null);\n  var lexer = {\n    source: source,\n    options: options,\n    lastToken: startOfFileToken,\n    token: startOfFileToken,\n    line: 1,\n    lineStart: 0,\n    advance: advanceLexer,\n    lookahead: lookahead\n  };\n  return lexer;\n}\n\nfunction advanceLexer() {\n  this.lastToken = this.token;\n  var token = this.token = this.lookahead();\n  return token;\n}\n\nfunction lookahead() {\n  var token = this.token;\n\n  if (token.kind !== TokenKind.EOF) {\n    do {\n      // Note: next is only mutable during parsing, so we cast to allow this.\n      token = token.next || (token.next = readToken(this, token));\n    } while (token.kind === TokenKind.COMMENT);\n  }\n\n  return token;\n}\n/**\n * The return type of createLexer.\n */\n\n\n// @internal\nexport function isPunctuatorToken(token) {\n  var kind = token.kind;\n  return kind === TokenKind.BANG || kind === TokenKind.DOLLAR || kind === TokenKind.AMP || kind === TokenKind.PAREN_L || kind === TokenKind.PAREN_R || kind === TokenKind.SPREAD || kind === TokenKind.COLON || kind === TokenKind.EQUALS || kind === TokenKind.AT || kind === TokenKind.BRACKET_L || kind === TokenKind.BRACKET_R || kind === TokenKind.BRACE_L || kind === TokenKind.PIPE || kind === TokenKind.BRACE_R;\n}\n/**\n * Helper function for constructing the Token object.\n */\n\nfunction Tok(kind, start, end, line, column, prev, value) {\n  this.kind = kind;\n  this.start = start;\n  this.end = end;\n  this.line = line;\n  this.column = column;\n  this.value = value;\n  this.prev = prev;\n  this.next = null;\n} // Print a simplified form when appearing in JSON/util.inspect.\n\n\ndefineToJSON(Tok, function () {\n  return {\n    kind: this.kind,\n    value: this.value,\n    line: this.line,\n    column: this.column\n  };\n});\n\nfunction printCharCode(code) {\n  return (// NaN/undefined represents access beyond the end of the file.\n    isNaN(code) ? TokenKind.EOF : // Trust JSON for ASCII.\n    code < 0x007f ? JSON.stringify(String.fromCharCode(code)) : // Otherwise print the escaped form.\n    \"\\\"\\\\u\".concat(('00' + code.toString(16).toUpperCase()).slice(-4), \"\\\"\")\n  );\n}\n/**\n * Gets the next token from the source starting at the given position.\n *\n * This skips over whitespace until it finds the next lexable token, then lexes\n * punctuators immediately or calls the appropriate helper function for more\n * complicated tokens.\n */\n\n\nfunction readToken(lexer, prev) {\n  var source = lexer.source;\n  var body = source.body;\n  var bodyLength = body.length;\n  var pos = positionAfterWhitespace(body, prev.end, lexer);\n  var line = lexer.line;\n  var col = 1 + pos - lexer.lineStart;\n\n  if (pos >= bodyLength) {\n    return new Tok(TokenKind.EOF, bodyLength, bodyLength, line, col, prev);\n  }\n\n  var code = body.charCodeAt(pos); // SourceCharacter\n\n  switch (code) {\n    // !\n    case 33:\n      return new Tok(TokenKind.BANG, pos, pos + 1, line, col, prev);\n    // #\n\n    case 35:\n      return readComment(source, pos, line, col, prev);\n    // $\n\n    case 36:\n      return new Tok(TokenKind.DOLLAR, pos, pos + 1, line, col, prev);\n    // &\n\n    case 38:\n      return new Tok(TokenKind.AMP, pos, pos + 1, line, col, prev);\n    // (\n\n    case 40:\n      return new Tok(TokenKind.PAREN_L, pos, pos + 1, line, col, prev);\n    // )\n\n    case 41:\n      return new Tok(TokenKind.PAREN_R, pos, pos + 1, line, col, prev);\n    // .\n\n    case 46:\n      if (body.charCodeAt(pos + 1) === 46 && body.charCodeAt(pos + 2) === 46) {\n        return new Tok(TokenKind.SPREAD, pos, pos + 3, line, col, prev);\n      }\n\n      break;\n    // :\n\n    case 58:\n      return new Tok(TokenKind.COLON, pos, pos + 1, line, col, prev);\n    // =\n\n    case 61:\n      return new Tok(TokenKind.EQUALS, pos, pos + 1, line, col, prev);\n    // @\n\n    case 64:\n      return new Tok(TokenKind.AT, pos, pos + 1, line, col, prev);\n    // [\n\n    case 91:\n      return new Tok(TokenKind.BRACKET_L, pos, pos + 1, line, col, prev);\n    // ]\n\n    case 93:\n      return new Tok(TokenKind.BRACKET_R, pos, pos + 1, line, col, prev);\n    // {\n\n    case 123:\n      return new Tok(TokenKind.BRACE_L, pos, pos + 1, line, col, prev);\n    // |\n\n    case 124:\n      return new Tok(TokenKind.PIPE, pos, pos + 1, line, col, prev);\n    // }\n\n    case 125:\n      return new Tok(TokenKind.BRACE_R, pos, pos + 1, line, col, prev);\n    // A-Z _ a-z\n\n    case 65:\n    case 66:\n    case 67:\n    case 68:\n    case 69:\n    case 70:\n    case 71:\n    case 72:\n    case 73:\n    case 74:\n    case 75:\n    case 76:\n    case 77:\n    case 78:\n    case 79:\n    case 80:\n    case 81:\n    case 82:\n    case 83:\n    case 84:\n    case 85:\n    case 86:\n    case 87:\n    case 88:\n    case 89:\n    case 90:\n    case 95:\n    case 97:\n    case 98:\n    case 99:\n    case 100:\n    case 101:\n    case 102:\n    case 103:\n    case 104:\n    case 105:\n    case 106:\n    case 107:\n    case 108:\n    case 109:\n    case 110:\n    case 111:\n    case 112:\n    case 113:\n    case 114:\n    case 115:\n    case 116:\n    case 117:\n    case 118:\n    case 119:\n    case 120:\n    case 121:\n    case 122:\n      return readName(source, pos, line, col, prev);\n    // - 0-9\n\n    case 45:\n    case 48:\n    case 49:\n    case 50:\n    case 51:\n    case 52:\n    case 53:\n    case 54:\n    case 55:\n    case 56:\n    case 57:\n      return readNumber(source, pos, code, line, col, prev);\n    // \"\n\n    case 34:\n      if (body.charCodeAt(pos + 1) === 34 && body.charCodeAt(pos + 2) === 34) {\n        return readBlockString(source, pos, line, col, prev, lexer);\n      }\n\n      return readString(source, pos, line, col, prev);\n  }\n\n  throw syntaxError(source, pos, unexpectedCharacterMessage(code));\n}\n/**\n * Report a message that an unexpected character was encountered.\n */\n\n\nfunction unexpectedCharacterMessage(code) {\n  if (code < 0x0020 && code !== 0x0009 && code !== 0x000a && code !== 0x000d) {\n    return \"Cannot contain the invalid character \".concat(printCharCode(code), \".\");\n  }\n\n  if (code === 39) {\n    // '\n    return 'Unexpected single quote character (\\'), did you mean to use a double quote (\")?';\n  }\n\n  return \"Cannot parse the unexpected character \".concat(printCharCode(code), \".\");\n}\n/**\n * Reads from body starting at startPosition until it finds a non-whitespace\n * character, then returns the position of that character for lexing.\n */\n\n\nfunction positionAfterWhitespace(body, startPosition, lexer) {\n  var bodyLength = body.length;\n  var position = startPosition;\n\n  while (position < bodyLength) {\n    var code = body.charCodeAt(position); // tab | space | comma | BOM\n\n    if (code === 9 || code === 32 || code === 44 || code === 0xfeff) {\n      ++position;\n    } else if (code === 10) {\n      // new line\n      ++position;\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else if (code === 13) {\n      // carriage return\n      if (body.charCodeAt(position + 1) === 10) {\n        position += 2;\n      } else {\n        ++position;\n      }\n\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else {\n      break;\n    }\n  }\n\n  return position;\n}\n/**\n * Reads a comment token from the source file.\n *\n * #[\\u0009\\u0020-\\uFFFF]*\n */\n\n\nfunction readComment(source, start, line, col, prev) {\n  var body = source.body;\n  var code;\n  var position = start;\n\n  do {\n    code = body.charCodeAt(++position);\n  } while (!isNaN(code) && ( // SourceCharacter but not LineTerminator\n  code > 0x001f || code === 0x0009));\n\n  return new Tok(TokenKind.COMMENT, start, position, line, col, prev, body.slice(start + 1, position));\n}\n/**\n * Reads a number token from the source file, either a float\n * or an int depending on whether a decimal point appears.\n *\n * Int:   -?(0|[1-9][0-9]*)\n * Float: -?(0|[1-9][0-9]*)(\\.[0-9]+)?((E|e)(+|-)?[0-9]+)?\n */\n\n\nfunction readNumber(source, start, firstCode, line, col, prev) {\n  var body = source.body;\n  var code = firstCode;\n  var position = start;\n  var isFloat = false;\n\n  if (code === 45) {\n    // -\n    code = body.charCodeAt(++position);\n  }\n\n  if (code === 48) {\n    // 0\n    code = body.charCodeAt(++position);\n\n    if (code >= 48 && code <= 57) {\n      throw syntaxError(source, position, \"Invalid number, unexpected digit after 0: \".concat(printCharCode(code), \".\"));\n    }\n  } else {\n    position = readDigits(source, position, code);\n    code = body.charCodeAt(position);\n  }\n\n  if (code === 46) {\n    // .\n    isFloat = true;\n    code = body.charCodeAt(++position);\n    position = readDigits(source, position, code);\n    code = body.charCodeAt(position);\n  }\n\n  if (code === 69 || code === 101) {\n    // E e\n    isFloat = true;\n    code = body.charCodeAt(++position);\n\n    if (code === 43 || code === 45) {\n      // + -\n      code = body.charCodeAt(++position);\n    }\n\n    position = readDigits(source, position, code);\n    code = body.charCodeAt(position);\n  } // Numbers cannot be followed by . or e\n\n\n  if (code === 46 || code === 69 || code === 101) {\n    throw syntaxError(source, position, \"Invalid number, expected digit but got: \".concat(printCharCode(code), \".\"));\n  }\n\n  return new Tok(isFloat ? TokenKind.FLOAT : TokenKind.INT, start, position, line, col, prev, body.slice(start, position));\n}\n/**\n * Returns the new position in the source after reading digits.\n */\n\n\nfunction readDigits(source, start, firstCode) {\n  var body = source.body;\n  var position = start;\n  var code = firstCode;\n\n  if (code >= 48 && code <= 57) {\n    // 0 - 9\n    do {\n      code = body.charCodeAt(++position);\n    } while (code >= 48 && code <= 57); // 0 - 9\n\n\n    return position;\n  }\n\n  throw syntaxError(source, position, \"Invalid number, expected digit but got: \".concat(printCharCode(code), \".\"));\n}\n/**\n * Reads a string token from the source file.\n *\n * \"([^\"\\\\\\u000A\\u000D]|(\\\\(u[0-9a-fA-F]{4}|[\"\\\\/bfnrt])))*\"\n */\n\n\nfunction readString(source, start, line, col, prev) {\n  var body = source.body;\n  var position = start + 1;\n  var chunkStart = position;\n  var code = 0;\n  var value = '';\n\n  while (position < body.length && !isNaN(code = body.charCodeAt(position)) && // not LineTerminator\n  code !== 0x000a && code !== 0x000d) {\n    // Closing Quote (\")\n    if (code === 34) {\n      value += body.slice(chunkStart, position);\n      return new Tok(TokenKind.STRING, start, position + 1, line, col, prev, value);\n    } // SourceCharacter\n\n\n    if (code < 0x0020 && code !== 0x0009) {\n      throw syntaxError(source, position, \"Invalid character within String: \".concat(printCharCode(code), \".\"));\n    }\n\n    ++position;\n\n    if (code === 92) {\n      // \\\n      value += body.slice(chunkStart, position - 1);\n      code = body.charCodeAt(position);\n\n      switch (code) {\n        case 34:\n          value += '\"';\n          break;\n\n        case 47:\n          value += '/';\n          break;\n\n        case 92:\n          value += '\\\\';\n          break;\n\n        case 98:\n          value += '\\b';\n          break;\n\n        case 102:\n          value += '\\f';\n          break;\n\n        case 110:\n          value += '\\n';\n          break;\n\n        case 114:\n          value += '\\r';\n          break;\n\n        case 116:\n          value += '\\t';\n          break;\n\n        case 117:\n          {\n            // uXXXX\n            var charCode = uniCharCode(body.charCodeAt(position + 1), body.charCodeAt(position + 2), body.charCodeAt(position + 3), body.charCodeAt(position + 4));\n\n            if (charCode < 0) {\n              var invalidSequence = body.slice(position + 1, position + 5);\n              throw syntaxError(source, position, \"Invalid character escape sequence: \\\\u\".concat(invalidSequence, \".\"));\n            }\n\n            value += String.fromCharCode(charCode);\n            position += 4;\n            break;\n          }\n\n        default:\n          throw syntaxError(source, position, \"Invalid character escape sequence: \\\\\".concat(String.fromCharCode(code), \".\"));\n      }\n\n      ++position;\n      chunkStart = position;\n    }\n  }\n\n  throw syntaxError(source, position, 'Unterminated string.');\n}\n/**\n * Reads a block string token from the source file.\n *\n * \"\"\"(\"?\"?(\\\\\"\"\"|\\\\(?!=\"\"\")|[^\"\\\\]))*\"\"\"\n */\n\n\nfunction readBlockString(source, start, line, col, prev, lexer) {\n  var body = source.body;\n  var position = start + 3;\n  var chunkStart = position;\n  var code = 0;\n  var rawValue = '';\n\n  while (position < body.length && !isNaN(code = body.charCodeAt(position))) {\n    // Closing Triple-Quote (\"\"\")\n    if (code === 34 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) {\n      rawValue += body.slice(chunkStart, position);\n      return new Tok(TokenKind.BLOCK_STRING, start, position + 3, line, col, prev, dedentBlockStringValue(rawValue));\n    } // SourceCharacter\n\n\n    if (code < 0x0020 && code !== 0x0009 && code !== 0x000a && code !== 0x000d) {\n      throw syntaxError(source, position, \"Invalid character within String: \".concat(printCharCode(code), \".\"));\n    }\n\n    if (code === 10) {\n      // new line\n      ++position;\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else if (code === 13) {\n      // carriage return\n      if (body.charCodeAt(position + 1) === 10) {\n        position += 2;\n      } else {\n        ++position;\n      }\n\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else if ( // Escape Triple-Quote (\\\"\"\")\n    code === 92 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34 && body.charCodeAt(position + 3) === 34) {\n      rawValue += body.slice(chunkStart, position) + '\"\"\"';\n      position += 4;\n      chunkStart = position;\n    } else {\n      ++position;\n    }\n  }\n\n  throw syntaxError(source, position, 'Unterminated string.');\n}\n/**\n * Converts four hexadecimal chars to the integer that the\n * string represents. For example, uniCharCode('0','0','0','f')\n * will return 15, and uniCharCode('0','0','f','f') returns 255.\n *\n * Returns a negative number on error, if a char was invalid.\n *\n * This is implemented by noting that char2hex() returns -1 on error,\n * which means the result of ORing the char2hex() will also be negative.\n */\n\n\nfunction uniCharCode(a, b, c, d) {\n  return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d);\n}\n/**\n * Converts a hex character to its integer value.\n * '0' becomes 0, '9' becomes 9\n * 'A' becomes 10, 'F' becomes 15\n * 'a' becomes 10, 'f' becomes 15\n *\n * Returns -1 on error.\n */\n\n\nfunction char2hex(a) {\n  return a >= 48 && a <= 57 ? a - 48 // 0-9\n  : a >= 65 && a <= 70 ? a - 55 // A-F\n  : a >= 97 && a <= 102 ? a - 87 // a-f\n  : -1;\n}\n/**\n * Reads an alphanumeric + underscore name from the source.\n *\n * [_A-Za-z][_0-9A-Za-z]*\n */\n\n\nfunction readName(source, start, line, col, prev) {\n  var body = source.body;\n  var bodyLength = body.length;\n  var position = start + 1;\n  var code = 0;\n\n  while (position !== bodyLength && !isNaN(code = body.charCodeAt(position)) && (code === 95 || // _\n  code >= 48 && code <= 57 || // 0-9\n  code >= 65 && code <= 90 || // A-Z\n  code >= 97 && code <= 122) // a-z\n  ) {\n    ++position;\n  }\n\n  return new Tok(TokenKind.NAME, start, position, line, col, prev, body.slice(start, position));\n}\n","/**\n * The set of allowed directive location values.\n */\nexport var DirectiveLocation = Object.freeze({\n  // Request Definitions\n  QUERY: 'QUERY',\n  MUTATION: 'MUTATION',\n  SUBSCRIPTION: 'SUBSCRIPTION',\n  FIELD: 'FIELD',\n  FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION',\n  FRAGMENT_SPREAD: 'FRAGMENT_SPREAD',\n  INLINE_FRAGMENT: 'INLINE_FRAGMENT',\n  VARIABLE_DEFINITION: 'VARIABLE_DEFINITION',\n  // Type System Definitions\n  SCHEMA: 'SCHEMA',\n  SCALAR: 'SCALAR',\n  OBJECT: 'OBJECT',\n  FIELD_DEFINITION: 'FIELD_DEFINITION',\n  ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION',\n  INTERFACE: 'INTERFACE',\n  UNION: 'UNION',\n  ENUM: 'ENUM',\n  ENUM_VALUE: 'ENUM_VALUE',\n  INPUT_OBJECT: 'INPUT_OBJECT',\n  INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'\n});\n/**\n * The enum type representing the directive location values.\n */\n","import inspect from '../jsutils/inspect';\nimport devAssert from '../jsutils/devAssert';\nimport defineToJSON from '../jsutils/defineToJSON';\nimport { syntaxError } from '../error/syntaxError';\nimport { Kind } from './kinds';\nimport { Source } from './source';\nimport { createLexer } from './lexer';\nimport { DirectiveLocation } from './directiveLocation';\nimport { TokenKind } from './tokenKind';\n\n/**\n * Given a GraphQL source, parses it into a Document.\n * Throws GraphQLError if a syntax error is encountered.\n */\nexport function parse(source, options) {\n  var parser = new Parser(source, options);\n  return parser.parseDocument();\n}\n/**\n * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for\n * that value.\n * Throws GraphQLError if a syntax error is encountered.\n *\n * This is useful within tools that operate upon GraphQL Values directly and\n * in isolation of complete GraphQL documents.\n *\n * Consider providing the results to the utility function: valueFromAST().\n */\n\nexport function parseValue(source, options) {\n  var parser = new Parser(source, options);\n  parser.expectToken(TokenKind.SOF);\n  var value = parser.parseValueLiteral(false);\n  parser.expectToken(TokenKind.EOF);\n  return value;\n}\n/**\n * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for\n * that type.\n * Throws GraphQLError if a syntax error is encountered.\n *\n * This is useful within tools that operate upon GraphQL Types directly and\n * in isolation of complete GraphQL documents.\n *\n * Consider providing the results to the utility function: typeFromAST().\n */\n\nexport function parseType(source, options) {\n  var parser = new Parser(source, options);\n  parser.expectToken(TokenKind.SOF);\n  var type = parser.parseTypeReference();\n  parser.expectToken(TokenKind.EOF);\n  return type;\n}\n\nvar Parser =\n/*#__PURE__*/\nfunction () {\n  function Parser(source, options) {\n    var sourceObj = typeof source === 'string' ? new Source(source) : source;\n    sourceObj instanceof Source || devAssert(0, \"Must provide Source. Received: \".concat(inspect(sourceObj)));\n    this._lexer = createLexer(sourceObj);\n    this._options = options || {};\n  }\n  /**\n   * Converts a name lex token into a name parse node.\n   */\n\n\n  var _proto = Parser.prototype;\n\n  _proto.parseName = function parseName() {\n    var token = this.expectToken(TokenKind.NAME);\n    return {\n      kind: Kind.NAME,\n      value: token.value,\n      loc: this.loc(token)\n    };\n  } // Implements the parsing rules in the Document section.\n\n  /**\n   * Document : Definition+\n   */\n  ;\n\n  _proto.parseDocument = function parseDocument() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.DOCUMENT,\n      definitions: this.many(TokenKind.SOF, this.parseDefinition, TokenKind.EOF),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Definition :\n   *   - ExecutableDefinition\n   *   - TypeSystemDefinition\n   *   - TypeSystemExtension\n   *\n   * ExecutableDefinition :\n   *   - OperationDefinition\n   *   - FragmentDefinition\n   */\n  ;\n\n  _proto.parseDefinition = function parseDefinition() {\n    if (this.peek(TokenKind.NAME)) {\n      switch (this._lexer.token.value) {\n        case 'query':\n        case 'mutation':\n        case 'subscription':\n          return this.parseOperationDefinition();\n\n        case 'fragment':\n          return this.parseFragmentDefinition();\n\n        case 'schema':\n        case 'scalar':\n        case 'type':\n        case 'interface':\n        case 'union':\n        case 'enum':\n        case 'input':\n        case 'directive':\n          return this.parseTypeSystemDefinition();\n\n        case 'extend':\n          return this.parseTypeSystemExtension();\n      }\n    } else if (this.peek(TokenKind.BRACE_L)) {\n      return this.parseOperationDefinition();\n    } else if (this.peekDescription()) {\n      return this.parseTypeSystemDefinition();\n    }\n\n    throw this.unexpected();\n  } // Implements the parsing rules in the Operations section.\n\n  /**\n   * OperationDefinition :\n   *  - SelectionSet\n   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet\n   */\n  ;\n\n  _proto.parseOperationDefinition = function parseOperationDefinition() {\n    var start = this._lexer.token;\n\n    if (this.peek(TokenKind.BRACE_L)) {\n      return {\n        kind: Kind.OPERATION_DEFINITION,\n        operation: 'query',\n        name: undefined,\n        variableDefinitions: [],\n        directives: [],\n        selectionSet: this.parseSelectionSet(),\n        loc: this.loc(start)\n      };\n    }\n\n    var operation = this.parseOperationType();\n    var name;\n\n    if (this.peek(TokenKind.NAME)) {\n      name = this.parseName();\n    }\n\n    return {\n      kind: Kind.OPERATION_DEFINITION,\n      operation: operation,\n      name: name,\n      variableDefinitions: this.parseVariableDefinitions(),\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * OperationType : one of query mutation subscription\n   */\n  ;\n\n  _proto.parseOperationType = function parseOperationType() {\n    var operationToken = this.expectToken(TokenKind.NAME);\n\n    switch (operationToken.value) {\n      case 'query':\n        return 'query';\n\n      case 'mutation':\n        return 'mutation';\n\n      case 'subscription':\n        return 'subscription';\n    }\n\n    throw this.unexpected(operationToken);\n  }\n  /**\n   * VariableDefinitions : ( VariableDefinition+ )\n   */\n  ;\n\n  _proto.parseVariableDefinitions = function parseVariableDefinitions() {\n    return this.optionalMany(TokenKind.PAREN_L, this.parseVariableDefinition, TokenKind.PAREN_R);\n  }\n  /**\n   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?\n   */\n  ;\n\n  _proto.parseVariableDefinition = function parseVariableDefinition() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.VARIABLE_DEFINITION,\n      variable: this.parseVariable(),\n      type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()),\n      defaultValue: this.expectOptionalToken(TokenKind.EQUALS) ? this.parseValueLiteral(true) : undefined,\n      directives: this.parseDirectives(true),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Variable : $ Name\n   */\n  ;\n\n  _proto.parseVariable = function parseVariable() {\n    var start = this._lexer.token;\n    this.expectToken(TokenKind.DOLLAR);\n    return {\n      kind: Kind.VARIABLE,\n      name: this.parseName(),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * SelectionSet : { Selection+ }\n   */\n  ;\n\n  _proto.parseSelectionSet = function parseSelectionSet() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.SELECTION_SET,\n      selections: this.many(TokenKind.BRACE_L, this.parseSelection, TokenKind.BRACE_R),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Selection :\n   *   - Field\n   *   - FragmentSpread\n   *   - InlineFragment\n   */\n  ;\n\n  _proto.parseSelection = function parseSelection() {\n    return this.peek(TokenKind.SPREAD) ? this.parseFragment() : this.parseField();\n  }\n  /**\n   * Field : Alias? Name Arguments? Directives? SelectionSet?\n   *\n   * Alias : Name :\n   */\n  ;\n\n  _proto.parseField = function parseField() {\n    var start = this._lexer.token;\n    var nameOrAlias = this.parseName();\n    var alias;\n    var name;\n\n    if (this.expectOptionalToken(TokenKind.COLON)) {\n      alias = nameOrAlias;\n      name = this.parseName();\n    } else {\n      name = nameOrAlias;\n    }\n\n    return {\n      kind: Kind.FIELD,\n      alias: alias,\n      name: name,\n      arguments: this.parseArguments(false),\n      directives: this.parseDirectives(false),\n      selectionSet: this.peek(TokenKind.BRACE_L) ? this.parseSelectionSet() : undefined,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Arguments[Const] : ( Argument[?Const]+ )\n   */\n  ;\n\n  _proto.parseArguments = function parseArguments(isConst) {\n    var item = isConst ? this.parseConstArgument : this.parseArgument;\n    return this.optionalMany(TokenKind.PAREN_L, item, TokenKind.PAREN_R);\n  }\n  /**\n   * Argument[Const] : Name : Value[?Const]\n   */\n  ;\n\n  _proto.parseArgument = function parseArgument() {\n    var start = this._lexer.token;\n    var name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    return {\n      kind: Kind.ARGUMENT,\n      name: name,\n      value: this.parseValueLiteral(false),\n      loc: this.loc(start)\n    };\n  };\n\n  _proto.parseConstArgument = function parseConstArgument() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.ARGUMENT,\n      name: this.parseName(),\n      value: (this.expectToken(TokenKind.COLON), this.parseValueLiteral(true)),\n      loc: this.loc(start)\n    };\n  } // Implements the parsing rules in the Fragments section.\n\n  /**\n   * Corresponds to both FragmentSpread and InlineFragment in the spec.\n   *\n   * FragmentSpread : ... FragmentName Directives?\n   *\n   * InlineFragment : ... TypeCondition? Directives? SelectionSet\n   */\n  ;\n\n  _proto.parseFragment = function parseFragment() {\n    var start = this._lexer.token;\n    this.expectToken(TokenKind.SPREAD);\n    var hasTypeCondition = this.expectOptionalKeyword('on');\n\n    if (!hasTypeCondition && this.peek(TokenKind.NAME)) {\n      return {\n        kind: Kind.FRAGMENT_SPREAD,\n        name: this.parseFragmentName(),\n        directives: this.parseDirectives(false),\n        loc: this.loc(start)\n      };\n    }\n\n    return {\n      kind: Kind.INLINE_FRAGMENT,\n      typeCondition: hasTypeCondition ? this.parseNamedType() : undefined,\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * FragmentDefinition :\n   *   - fragment FragmentName on TypeCondition Directives? SelectionSet\n   *\n   * TypeCondition : NamedType\n   */\n  ;\n\n  _proto.parseFragmentDefinition = function parseFragmentDefinition() {\n    var start = this._lexer.token;\n    this.expectKeyword('fragment'); // Experimental support for defining variables within fragments changes\n    // the grammar of FragmentDefinition:\n    //   - fragment FragmentName VariableDefinitions? on TypeCondition Directives? SelectionSet\n\n    if (this._options.experimentalFragmentVariables) {\n      return {\n        kind: Kind.FRAGMENT_DEFINITION,\n        name: this.parseFragmentName(),\n        variableDefinitions: this.parseVariableDefinitions(),\n        typeCondition: (this.expectKeyword('on'), this.parseNamedType()),\n        directives: this.parseDirectives(false),\n        selectionSet: this.parseSelectionSet(),\n        loc: this.loc(start)\n      };\n    }\n\n    return {\n      kind: Kind.FRAGMENT_DEFINITION,\n      name: this.parseFragmentName(),\n      typeCondition: (this.expectKeyword('on'), this.parseNamedType()),\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * FragmentName : Name but not `on`\n   */\n  ;\n\n  _proto.parseFragmentName = function parseFragmentName() {\n    if (this._lexer.token.value === 'on') {\n      throw this.unexpected();\n    }\n\n    return this.parseName();\n  } // Implements the parsing rules in the Values section.\n\n  /**\n   * Value[Const] :\n   *   - [~Const] Variable\n   *   - IntValue\n   *   - FloatValue\n   *   - StringValue\n   *   - BooleanValue\n   *   - NullValue\n   *   - EnumValue\n   *   - ListValue[?Const]\n   *   - ObjectValue[?Const]\n   *\n   * BooleanValue : one of `true` `false`\n   *\n   * NullValue : `null`\n   *\n   * EnumValue : Name but not `true`, `false` or `null`\n   */\n  ;\n\n  _proto.parseValueLiteral = function parseValueLiteral(isConst) {\n    var token = this._lexer.token;\n\n    switch (token.kind) {\n      case TokenKind.BRACKET_L:\n        return this.parseList(isConst);\n\n      case TokenKind.BRACE_L:\n        return this.parseObject(isConst);\n\n      case TokenKind.INT:\n        this._lexer.advance();\n\n        return {\n          kind: Kind.INT,\n          value: token.value,\n          loc: this.loc(token)\n        };\n\n      case TokenKind.FLOAT:\n        this._lexer.advance();\n\n        return {\n          kind: Kind.FLOAT,\n          value: token.value,\n          loc: this.loc(token)\n        };\n\n      case TokenKind.STRING:\n      case TokenKind.BLOCK_STRING:\n        return this.parseStringLiteral();\n\n      case TokenKind.NAME:\n        if (token.value === 'true' || token.value === 'false') {\n          this._lexer.advance();\n\n          return {\n            kind: Kind.BOOLEAN,\n            value: token.value === 'true',\n            loc: this.loc(token)\n          };\n        } else if (token.value === 'null') {\n          this._lexer.advance();\n\n          return {\n            kind: Kind.NULL,\n            loc: this.loc(token)\n          };\n        }\n\n        this._lexer.advance();\n\n        return {\n          kind: Kind.ENUM,\n          value: token.value,\n          loc: this.loc(token)\n        };\n\n      case TokenKind.DOLLAR:\n        if (!isConst) {\n          return this.parseVariable();\n        }\n\n        break;\n    }\n\n    throw this.unexpected();\n  };\n\n  _proto.parseStringLiteral = function parseStringLiteral() {\n    var token = this._lexer.token;\n\n    this._lexer.advance();\n\n    return {\n      kind: Kind.STRING,\n      value: token.value,\n      block: token.kind === TokenKind.BLOCK_STRING,\n      loc: this.loc(token)\n    };\n  }\n  /**\n   * ListValue[Const] :\n   *   - [ ]\n   *   - [ Value[?Const]+ ]\n   */\n  ;\n\n  _proto.parseList = function parseList(isConst) {\n    var _this = this;\n\n    var start = this._lexer.token;\n\n    var item = function item() {\n      return _this.parseValueLiteral(isConst);\n    };\n\n    return {\n      kind: Kind.LIST,\n      values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ObjectValue[Const] :\n   *   - { }\n   *   - { ObjectField[?Const]+ }\n   */\n  ;\n\n  _proto.parseObject = function parseObject(isConst) {\n    var _this2 = this;\n\n    var start = this._lexer.token;\n\n    var item = function item() {\n      return _this2.parseObjectField(isConst);\n    };\n\n    return {\n      kind: Kind.OBJECT,\n      fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ObjectField[Const] : Name : Value[?Const]\n   */\n  ;\n\n  _proto.parseObjectField = function parseObjectField(isConst) {\n    var start = this._lexer.token;\n    var name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    return {\n      kind: Kind.OBJECT_FIELD,\n      name: name,\n      value: this.parseValueLiteral(isConst),\n      loc: this.loc(start)\n    };\n  } // Implements the parsing rules in the Directives section.\n\n  /**\n   * Directives[Const] : Directive[?Const]+\n   */\n  ;\n\n  _proto.parseDirectives = function parseDirectives(isConst) {\n    var directives = [];\n\n    while (this.peek(TokenKind.AT)) {\n      directives.push(this.parseDirective(isConst));\n    }\n\n    return directives;\n  }\n  /**\n   * Directive[Const] : @ Name Arguments[?Const]?\n   */\n  ;\n\n  _proto.parseDirective = function parseDirective(isConst) {\n    var start = this._lexer.token;\n    this.expectToken(TokenKind.AT);\n    return {\n      kind: Kind.DIRECTIVE,\n      name: this.parseName(),\n      arguments: this.parseArguments(isConst),\n      loc: this.loc(start)\n    };\n  } // Implements the parsing rules in the Types section.\n\n  /**\n   * Type :\n   *   - NamedType\n   *   - ListType\n   *   - NonNullType\n   */\n  ;\n\n  _proto.parseTypeReference = function parseTypeReference() {\n    var start = this._lexer.token;\n    var type;\n\n    if (this.expectOptionalToken(TokenKind.BRACKET_L)) {\n      type = this.parseTypeReference();\n      this.expectToken(TokenKind.BRACKET_R);\n      type = {\n        kind: Kind.LIST_TYPE,\n        type: type,\n        loc: this.loc(start)\n      };\n    } else {\n      type = this.parseNamedType();\n    }\n\n    if (this.expectOptionalToken(TokenKind.BANG)) {\n      return {\n        kind: Kind.NON_NULL_TYPE,\n        type: type,\n        loc: this.loc(start)\n      };\n    }\n\n    return type;\n  }\n  /**\n   * NamedType : Name\n   */\n  ;\n\n  _proto.parseNamedType = function parseNamedType() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.NAMED_TYPE,\n      name: this.parseName(),\n      loc: this.loc(start)\n    };\n  } // Implements the parsing rules in the Type Definition section.\n\n  /**\n   * TypeSystemDefinition :\n   *   - SchemaDefinition\n   *   - TypeDefinition\n   *   - DirectiveDefinition\n   *\n   * TypeDefinition :\n   *   - ScalarTypeDefinition\n   *   - ObjectTypeDefinition\n   *   - InterfaceTypeDefinition\n   *   - UnionTypeDefinition\n   *   - EnumTypeDefinition\n   *   - InputObjectTypeDefinition\n   */\n  ;\n\n  _proto.parseTypeSystemDefinition = function parseTypeSystemDefinition() {\n    // Many definitions begin with a description and require a lookahead.\n    var keywordToken = this.peekDescription() ? this._lexer.lookahead() : this._lexer.token;\n\n    if (keywordToken.kind === TokenKind.NAME) {\n      switch (keywordToken.value) {\n        case 'schema':\n          return this.parseSchemaDefinition();\n\n        case 'scalar':\n          return this.parseScalarTypeDefinition();\n\n        case 'type':\n          return this.parseObjectTypeDefinition();\n\n        case 'interface':\n          return this.parseInterfaceTypeDefinition();\n\n        case 'union':\n          return this.parseUnionTypeDefinition();\n\n        case 'enum':\n          return this.parseEnumTypeDefinition();\n\n        case 'input':\n          return this.parseInputObjectTypeDefinition();\n\n        case 'directive':\n          return this.parseDirectiveDefinition();\n      }\n    }\n\n    throw this.unexpected(keywordToken);\n  };\n\n  _proto.peekDescription = function peekDescription() {\n    return this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING);\n  }\n  /**\n   * Description : StringValue\n   */\n  ;\n\n  _proto.parseDescription = function parseDescription() {\n    if (this.peekDescription()) {\n      return this.parseStringLiteral();\n    }\n  }\n  /**\n   * SchemaDefinition : schema Directives[Const]? { OperationTypeDefinition+ }\n   */\n  ;\n\n  _proto.parseSchemaDefinition = function parseSchemaDefinition() {\n    var start = this._lexer.token;\n    this.expectKeyword('schema');\n    var directives = this.parseDirectives(true);\n    var operationTypes = this.many(TokenKind.BRACE_L, this.parseOperationTypeDefinition, TokenKind.BRACE_R);\n    return {\n      kind: Kind.SCHEMA_DEFINITION,\n      directives: directives,\n      operationTypes: operationTypes,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * OperationTypeDefinition : OperationType : NamedType\n   */\n  ;\n\n  _proto.parseOperationTypeDefinition = function parseOperationTypeDefinition() {\n    var start = this._lexer.token;\n    var operation = this.parseOperationType();\n    this.expectToken(TokenKind.COLON);\n    var type = this.parseNamedType();\n    return {\n      kind: Kind.OPERATION_TYPE_DEFINITION,\n      operation: operation,\n      type: type,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?\n   */\n  ;\n\n  _proto.parseScalarTypeDefinition = function parseScalarTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('scalar');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.SCALAR_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ObjectTypeDefinition :\n   *   Description?\n   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?\n   */\n  ;\n\n  _proto.parseObjectTypeDefinition = function parseObjectTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('type');\n    var name = this.parseName();\n    var interfaces = this.parseImplementsInterfaces();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n    return {\n      kind: Kind.OBJECT_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      interfaces: interfaces,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ImplementsInterfaces :\n   *   - implements `&`? NamedType\n   *   - ImplementsInterfaces & NamedType\n   */\n  ;\n\n  _proto.parseImplementsInterfaces = function parseImplementsInterfaces() {\n    var types = [];\n\n    if (this.expectOptionalKeyword('implements')) {\n      // Optional leading ampersand\n      this.expectOptionalToken(TokenKind.AMP);\n\n      do {\n        types.push(this.parseNamedType());\n      } while (this.expectOptionalToken(TokenKind.AMP) || // Legacy support for the SDL?\n      this._options.allowLegacySDLImplementsInterfaces && this.peek(TokenKind.NAME));\n    }\n\n    return types;\n  }\n  /**\n   * FieldsDefinition : { FieldDefinition+ }\n   */\n  ;\n\n  _proto.parseFieldsDefinition = function parseFieldsDefinition() {\n    // Legacy support for the SDL?\n    if (this._options.allowLegacySDLEmptyFields && this.peek(TokenKind.BRACE_L) && this._lexer.lookahead().kind === TokenKind.BRACE_R) {\n      this._lexer.advance();\n\n      this._lexer.advance();\n\n      return [];\n    }\n\n    return this.optionalMany(TokenKind.BRACE_L, this.parseFieldDefinition, TokenKind.BRACE_R);\n  }\n  /**\n   * FieldDefinition :\n   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?\n   */\n  ;\n\n  _proto.parseFieldDefinition = function parseFieldDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    var name = this.parseName();\n    var args = this.parseArgumentDefs();\n    this.expectToken(TokenKind.COLON);\n    var type = this.parseTypeReference();\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.FIELD_DEFINITION,\n      description: description,\n      name: name,\n      arguments: args,\n      type: type,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ArgumentsDefinition : ( InputValueDefinition+ )\n   */\n  ;\n\n  _proto.parseArgumentDefs = function parseArgumentDefs() {\n    return this.optionalMany(TokenKind.PAREN_L, this.parseInputValueDef, TokenKind.PAREN_R);\n  }\n  /**\n   * InputValueDefinition :\n   *   - Description? Name : Type DefaultValue? Directives[Const]?\n   */\n  ;\n\n  _proto.parseInputValueDef = function parseInputValueDef() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    var name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    var type = this.parseTypeReference();\n    var defaultValue;\n\n    if (this.expectOptionalToken(TokenKind.EQUALS)) {\n      defaultValue = this.parseValueLiteral(true);\n    }\n\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.INPUT_VALUE_DEFINITION,\n      description: description,\n      name: name,\n      type: type,\n      defaultValue: defaultValue,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InterfaceTypeDefinition :\n   *   - Description? interface Name Directives[Const]? FieldsDefinition?\n   */\n  ;\n\n  _proto.parseInterfaceTypeDefinition = function parseInterfaceTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('interface');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n    return {\n      kind: Kind.INTERFACE_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * UnionTypeDefinition :\n   *   - Description? union Name Directives[Const]? UnionMemberTypes?\n   */\n  ;\n\n  _proto.parseUnionTypeDefinition = function parseUnionTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('union');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var types = this.parseUnionMemberTypes();\n    return {\n      kind: Kind.UNION_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      types: types,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * UnionMemberTypes :\n   *   - = `|`? NamedType\n   *   - UnionMemberTypes | NamedType\n   */\n  ;\n\n  _proto.parseUnionMemberTypes = function parseUnionMemberTypes() {\n    var types = [];\n\n    if (this.expectOptionalToken(TokenKind.EQUALS)) {\n      // Optional leading pipe\n      this.expectOptionalToken(TokenKind.PIPE);\n\n      do {\n        types.push(this.parseNamedType());\n      } while (this.expectOptionalToken(TokenKind.PIPE));\n    }\n\n    return types;\n  }\n  /**\n   * EnumTypeDefinition :\n   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?\n   */\n  ;\n\n  _proto.parseEnumTypeDefinition = function parseEnumTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('enum');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var values = this.parseEnumValuesDefinition();\n    return {\n      kind: Kind.ENUM_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      values: values,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * EnumValuesDefinition : { EnumValueDefinition+ }\n   */\n  ;\n\n  _proto.parseEnumValuesDefinition = function parseEnumValuesDefinition() {\n    return this.optionalMany(TokenKind.BRACE_L, this.parseEnumValueDefinition, TokenKind.BRACE_R);\n  }\n  /**\n   * EnumValueDefinition : Description? EnumValue Directives[Const]?\n   *\n   * EnumValue : Name\n   */\n  ;\n\n  _proto.parseEnumValueDefinition = function parseEnumValueDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.ENUM_VALUE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InputObjectTypeDefinition :\n   *   - Description? input Name Directives[Const]? InputFieldsDefinition?\n   */\n  ;\n\n  _proto.parseInputObjectTypeDefinition = function parseInputObjectTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('input');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseInputFieldsDefinition();\n    return {\n      kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InputFieldsDefinition : { InputValueDefinition+ }\n   */\n  ;\n\n  _proto.parseInputFieldsDefinition = function parseInputFieldsDefinition() {\n    return this.optionalMany(TokenKind.BRACE_L, this.parseInputValueDef, TokenKind.BRACE_R);\n  }\n  /**\n   * TypeSystemExtension :\n   *   - SchemaExtension\n   *   - TypeExtension\n   *\n   * TypeExtension :\n   *   - ScalarTypeExtension\n   *   - ObjectTypeExtension\n   *   - InterfaceTypeExtension\n   *   - UnionTypeExtension\n   *   - EnumTypeExtension\n   *   - InputObjectTypeDefinition\n   */\n  ;\n\n  _proto.parseTypeSystemExtension = function parseTypeSystemExtension() {\n    var keywordToken = this._lexer.lookahead();\n\n    if (keywordToken.kind === TokenKind.NAME) {\n      switch (keywordToken.value) {\n        case 'schema':\n          return this.parseSchemaExtension();\n\n        case 'scalar':\n          return this.parseScalarTypeExtension();\n\n        case 'type':\n          return this.parseObjectTypeExtension();\n\n        case 'interface':\n          return this.parseInterfaceTypeExtension();\n\n        case 'union':\n          return this.parseUnionTypeExtension();\n\n        case 'enum':\n          return this.parseEnumTypeExtension();\n\n        case 'input':\n          return this.parseInputObjectTypeExtension();\n      }\n    }\n\n    throw this.unexpected(keywordToken);\n  }\n  /**\n   * SchemaExtension :\n   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }\n   *  - extend schema Directives[Const]\n   */\n  ;\n\n  _proto.parseSchemaExtension = function parseSchemaExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('schema');\n    var directives = this.parseDirectives(true);\n    var operationTypes = this.optionalMany(TokenKind.BRACE_L, this.parseOperationTypeDefinition, TokenKind.BRACE_R);\n\n    if (directives.length === 0 && operationTypes.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.SCHEMA_EXTENSION,\n      directives: directives,\n      operationTypes: operationTypes,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ScalarTypeExtension :\n   *   - extend scalar Name Directives[Const]\n   */\n  ;\n\n  _proto.parseScalarTypeExtension = function parseScalarTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('scalar');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n\n    if (directives.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.SCALAR_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ObjectTypeExtension :\n   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition\n   *  - extend type Name ImplementsInterfaces? Directives[Const]\n   *  - extend type Name ImplementsInterfaces\n   */\n  ;\n\n  _proto.parseObjectTypeExtension = function parseObjectTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('type');\n    var name = this.parseName();\n    var interfaces = this.parseImplementsInterfaces();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n\n    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.OBJECT_TYPE_EXTENSION,\n      name: name,\n      interfaces: interfaces,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InterfaceTypeExtension :\n   *   - extend interface Name Directives[Const]? FieldsDefinition\n   *   - extend interface Name Directives[Const]\n   */\n  ;\n\n  _proto.parseInterfaceTypeExtension = function parseInterfaceTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('interface');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n\n    if (directives.length === 0 && fields.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.INTERFACE_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * UnionTypeExtension :\n   *   - extend union Name Directives[Const]? UnionMemberTypes\n   *   - extend union Name Directives[Const]\n   */\n  ;\n\n  _proto.parseUnionTypeExtension = function parseUnionTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('union');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var types = this.parseUnionMemberTypes();\n\n    if (directives.length === 0 && types.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.UNION_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      types: types,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * EnumTypeExtension :\n   *   - extend enum Name Directives[Const]? EnumValuesDefinition\n   *   - extend enum Name Directives[Const]\n   */\n  ;\n\n  _proto.parseEnumTypeExtension = function parseEnumTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('enum');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var values = this.parseEnumValuesDefinition();\n\n    if (directives.length === 0 && values.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.ENUM_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      values: values,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InputObjectTypeExtension :\n   *   - extend input Name Directives[Const]? InputFieldsDefinition\n   *   - extend input Name Directives[Const]\n   */\n  ;\n\n  _proto.parseInputObjectTypeExtension = function parseInputObjectTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('input');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseInputFieldsDefinition();\n\n    if (directives.length === 0 && fields.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * DirectiveDefinition :\n   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations\n   */\n  ;\n\n  _proto.parseDirectiveDefinition = function parseDirectiveDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('directive');\n    this.expectToken(TokenKind.AT);\n    var name = this.parseName();\n    var args = this.parseArgumentDefs();\n    var repeatable = this.expectOptionalKeyword('repeatable');\n    this.expectKeyword('on');\n    var locations = this.parseDirectiveLocations();\n    return {\n      kind: Kind.DIRECTIVE_DEFINITION,\n      description: description,\n      name: name,\n      arguments: args,\n      repeatable: repeatable,\n      locations: locations,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * DirectiveLocations :\n   *   - `|`? DirectiveLocation\n   *   - DirectiveLocations | DirectiveLocation\n   */\n  ;\n\n  _proto.parseDirectiveLocations = function parseDirectiveLocations() {\n    // Optional leading pipe\n    this.expectOptionalToken(TokenKind.PIPE);\n    var locations = [];\n\n    do {\n      locations.push(this.parseDirectiveLocation());\n    } while (this.expectOptionalToken(TokenKind.PIPE));\n\n    return locations;\n  }\n  /*\n   * DirectiveLocation :\n   *   - ExecutableDirectiveLocation\n   *   - TypeSystemDirectiveLocation\n   *\n   * ExecutableDirectiveLocation : one of\n   *   `QUERY`\n   *   `MUTATION`\n   *   `SUBSCRIPTION`\n   *   `FIELD`\n   *   `FRAGMENT_DEFINITION`\n   *   `FRAGMENT_SPREAD`\n   *   `INLINE_FRAGMENT`\n   *\n   * TypeSystemDirectiveLocation : one of\n   *   `SCHEMA`\n   *   `SCALAR`\n   *   `OBJECT`\n   *   `FIELD_DEFINITION`\n   *   `ARGUMENT_DEFINITION`\n   *   `INTERFACE`\n   *   `UNION`\n   *   `ENUM`\n   *   `ENUM_VALUE`\n   *   `INPUT_OBJECT`\n   *   `INPUT_FIELD_DEFINITION`\n   */\n  ;\n\n  _proto.parseDirectiveLocation = function parseDirectiveLocation() {\n    var start = this._lexer.token;\n    var name = this.parseName();\n\n    if (DirectiveLocation[name.value] !== undefined) {\n      return name;\n    }\n\n    throw this.unexpected(start);\n  } // Core parsing utility functions\n\n  /**\n   * Returns a location object, used to identify the place in\n   * the source that created a given parsed object.\n   */\n  ;\n\n  _proto.loc = function loc(startToken) {\n    if (!this._options.noLocation) {\n      return new Loc(startToken, this._lexer.lastToken, this._lexer.source);\n    }\n  }\n  /**\n   * Determines if the next token is of a given kind\n   */\n  ;\n\n  _proto.peek = function peek(kind) {\n    return this._lexer.token.kind === kind;\n  }\n  /**\n   * If the next token is of the given kind, return that token after advancing\n   * the lexer. Otherwise, do not change the parser state and throw an error.\n   */\n  ;\n\n  _proto.expectToken = function expectToken(kind) {\n    var token = this._lexer.token;\n\n    if (token.kind === kind) {\n      this._lexer.advance();\n\n      return token;\n    }\n\n    throw syntaxError(this._lexer.source, token.start, \"Expected \".concat(kind, \", found \").concat(getTokenDesc(token)));\n  }\n  /**\n   * If the next token is of the given kind, return that token after advancing\n   * the lexer. Otherwise, do not change the parser state and return undefined.\n   */\n  ;\n\n  _proto.expectOptionalToken = function expectOptionalToken(kind) {\n    var token = this._lexer.token;\n\n    if (token.kind === kind) {\n      this._lexer.advance();\n\n      return token;\n    }\n\n    return undefined;\n  }\n  /**\n   * If the next token is a given keyword, advance the lexer.\n   * Otherwise, do not change the parser state and throw an error.\n   */\n  ;\n\n  _proto.expectKeyword = function expectKeyword(value) {\n    var token = this._lexer.token;\n\n    if (token.kind === TokenKind.NAME && token.value === value) {\n      this._lexer.advance();\n    } else {\n      throw syntaxError(this._lexer.source, token.start, \"Expected \\\"\".concat(value, \"\\\", found \").concat(getTokenDesc(token)));\n    }\n  }\n  /**\n   * If the next token is a given keyword, return \"true\" after advancing\n   * the lexer. Otherwise, do not change the parser state and return \"false\".\n   */\n  ;\n\n  _proto.expectOptionalKeyword = function expectOptionalKeyword(value) {\n    var token = this._lexer.token;\n\n    if (token.kind === TokenKind.NAME && token.value === value) {\n      this._lexer.advance();\n\n      return true;\n    }\n\n    return false;\n  }\n  /**\n   * Helper function for creating an error when an unexpected lexed token\n   * is encountered.\n   */\n  ;\n\n  _proto.unexpected = function unexpected(atToken) {\n    var token = atToken || this._lexer.token;\n    return syntaxError(this._lexer.source, token.start, \"Unexpected \".concat(getTokenDesc(token)));\n  }\n  /**\n   * Returns a possibly empty list of parse nodes, determined by\n   * the parseFn. This list begins with a lex token of openKind\n   * and ends with a lex token of closeKind. Advances the parser\n   * to the next lex token after the closing token.\n   */\n  ;\n\n  _proto.any = function any(openKind, parseFn, closeKind) {\n    this.expectToken(openKind);\n    var nodes = [];\n\n    while (!this.expectOptionalToken(closeKind)) {\n      nodes.push(parseFn.call(this));\n    }\n\n    return nodes;\n  }\n  /**\n   * Returns a list of parse nodes, determined by the parseFn.\n   * It can be empty only if open token is missing otherwise it will always\n   * return non-empty list that begins with a lex token of openKind and ends\n   * with a lex token of closeKind. Advances the parser to the next lex token\n   * after the closing token.\n   */\n  ;\n\n  _proto.optionalMany = function optionalMany(openKind, parseFn, closeKind) {\n    if (this.expectOptionalToken(openKind)) {\n      var nodes = [];\n\n      do {\n        nodes.push(parseFn.call(this));\n      } while (!this.expectOptionalToken(closeKind));\n\n      return nodes;\n    }\n\n    return [];\n  }\n  /**\n   * Returns a non-empty list of parse nodes, determined by\n   * the parseFn. This list begins with a lex token of openKind\n   * and ends with a lex token of closeKind. Advances the parser\n   * to the next lex token after the closing token.\n   */\n  ;\n\n  _proto.many = function many(openKind, parseFn, closeKind) {\n    this.expectToken(openKind);\n    var nodes = [];\n\n    do {\n      nodes.push(parseFn.call(this));\n    } while (!this.expectOptionalToken(closeKind));\n\n    return nodes;\n  };\n\n  return Parser;\n}();\n\nfunction Loc(startToken, endToken, source) {\n  this.start = startToken.start;\n  this.end = endToken.end;\n  this.startToken = startToken;\n  this.endToken = endToken;\n  this.source = source;\n} // Print a simplified form when appearing in JSON/util.inspect.\n\n\ndefineToJSON(Loc, function () {\n  return {\n    start: this.start,\n    end: this.end\n  };\n});\n/**\n * A helper function to describe a token as a string for debugging\n */\n\nfunction getTokenDesc(token) {\n  var value = token.value;\n  return value ? \"\".concat(token.kind, \" \\\"\").concat(value, \"\\\"\") : token.kind;\n}\n","import inspect from '../jsutils/inspect';\nexport var QueryDocumentKeys = {\n  Name: [],\n  Document: ['definitions'],\n  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],\n  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],\n  Variable: ['name'],\n  SelectionSet: ['selections'],\n  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],\n  Argument: ['name', 'value'],\n  FragmentSpread: ['name', 'directives'],\n  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],\n  FragmentDefinition: ['name', // Note: fragment variable definitions are experimental and may be changed\n  // or removed in the future.\n  'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],\n  IntValue: [],\n  FloatValue: [],\n  StringValue: [],\n  BooleanValue: [],\n  NullValue: [],\n  EnumValue: [],\n  ListValue: ['values'],\n  ObjectValue: ['fields'],\n  ObjectField: ['name', 'value'],\n  Directive: ['name', 'arguments'],\n  NamedType: ['name'],\n  ListType: ['type'],\n  NonNullType: ['type'],\n  SchemaDefinition: ['directives', 'operationTypes'],\n  OperationTypeDefinition: ['type'],\n  ScalarTypeDefinition: ['description', 'name', 'directives'],\n  ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],\n  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],\n  InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],\n  InterfaceTypeDefinition: ['description', 'name', 'directives', 'fields'],\n  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],\n  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],\n  EnumValueDefinition: ['description', 'name', 'directives'],\n  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],\n  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],\n  SchemaExtension: ['directives', 'operationTypes'],\n  ScalarTypeExtension: ['name', 'directives'],\n  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],\n  InterfaceTypeExtension: ['name', 'directives', 'fields'],\n  UnionTypeExtension: ['name', 'directives', 'types'],\n  EnumTypeExtension: ['name', 'directives', 'values'],\n  InputObjectTypeExtension: ['name', 'directives', 'fields']\n};\nexport var BREAK = Object.freeze({});\n/**\n * visit() will walk through an AST using a depth first traversal, calling\n * the visitor's enter function at each node in the traversal, and calling the\n * leave function after visiting that node and all of its child nodes.\n *\n * By returning different values from the enter and leave functions, the\n * behavior of the visitor can be altered, including skipping over a sub-tree of\n * the AST (by returning false), editing the AST by returning a value or null\n * to remove the value, or to stop the whole traversal by returning BREAK.\n *\n * When using visit() to edit an AST, the original AST will not be modified, and\n * a new version of the AST with the changes applied will be returned from the\n * visit function.\n *\n *     const editedAST = visit(ast, {\n *       enter(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: skip visiting this node\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       },\n *       leave(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: no action\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       }\n *     });\n *\n * Alternatively to providing enter() and leave() functions, a visitor can\n * instead provide functions named the same as the kinds of AST nodes, or\n * enter/leave visitors at a named key, leading to four permutations of\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node a specific kind.\n *\n *     visit(ast, {\n *       Kind(node) {\n *         // enter the \"Kind\" node\n *       }\n *     })\n *\n * 2) Named visitors that trigger upon entering and leaving a node of\n *    a specific kind.\n *\n *     visit(ast, {\n *       Kind: {\n *         enter(node) {\n *           // enter the \"Kind\" node\n *         }\n *         leave(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n *\n * 3) Generic visitors that trigger upon entering and leaving any node.\n *\n *     visit(ast, {\n *       enter(node) {\n *         // enter any node\n *       },\n *       leave(node) {\n *         // leave any node\n *       }\n *     })\n *\n * 4) Parallel visitors for entering and leaving nodes of a specific kind.\n *\n *     visit(ast, {\n *       enter: {\n *         Kind(node) {\n *           // enter the \"Kind\" node\n *         }\n *       },\n *       leave: {\n *         Kind(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n */\n\nexport function visit(root, visitor) {\n  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;\n\n  /* eslint-disable no-undef-init */\n  var stack = undefined;\n  var inArray = Array.isArray(root);\n  var keys = [root];\n  var index = -1;\n  var edits = [];\n  var node = undefined;\n  var key = undefined;\n  var parent = undefined;\n  var path = [];\n  var ancestors = [];\n  var newRoot = root;\n  /* eslint-enable no-undef-init */\n\n  do {\n    index++;\n    var isLeaving = index === keys.length;\n    var isEdited = isLeaving && edits.length !== 0;\n\n    if (isLeaving) {\n      key = ancestors.length === 0 ? undefined : path[path.length - 1];\n      node = parent;\n      parent = ancestors.pop();\n\n      if (isEdited) {\n        if (inArray) {\n          node = node.slice();\n        } else {\n          var clone = {};\n\n          for (var _i2 = 0, _Object$keys2 = Object.keys(node); _i2 < _Object$keys2.length; _i2++) {\n            var k = _Object$keys2[_i2];\n            clone[k] = node[k];\n          }\n\n          node = clone;\n        }\n\n        var editOffset = 0;\n\n        for (var ii = 0; ii < edits.length; ii++) {\n          var editKey = edits[ii][0];\n          var editValue = edits[ii][1];\n\n          if (inArray) {\n            editKey -= editOffset;\n          }\n\n          if (inArray && editValue === null) {\n            node.splice(editKey, 1);\n            editOffset++;\n          } else {\n            node[editKey] = editValue;\n          }\n        }\n      }\n\n      index = stack.index;\n      keys = stack.keys;\n      edits = stack.edits;\n      inArray = stack.inArray;\n      stack = stack.prev;\n    } else {\n      key = parent ? inArray ? index : keys[index] : undefined;\n      node = parent ? parent[key] : newRoot;\n\n      if (node === null || node === undefined) {\n        continue;\n      }\n\n      if (parent) {\n        path.push(key);\n      }\n    }\n\n    var result = void 0;\n\n    if (!Array.isArray(node)) {\n      if (!isNode(node)) {\n        throw new Error('Invalid AST Node: ' + inspect(node));\n      }\n\n      var visitFn = getVisitFn(visitor, node.kind, isLeaving);\n\n      if (visitFn) {\n        result = visitFn.call(visitor, node, key, parent, path, ancestors);\n\n        if (result === BREAK) {\n          break;\n        }\n\n        if (result === false) {\n          if (!isLeaving) {\n            path.pop();\n            continue;\n          }\n        } else if (result !== undefined) {\n          edits.push([key, result]);\n\n          if (!isLeaving) {\n            if (isNode(result)) {\n              node = result;\n            } else {\n              path.pop();\n              continue;\n            }\n          }\n        }\n      }\n    }\n\n    if (result === undefined && isEdited) {\n      edits.push([key, node]);\n    }\n\n    if (isLeaving) {\n      path.pop();\n    } else {\n      stack = {\n        inArray: inArray,\n        index: index,\n        keys: keys,\n        edits: edits,\n        prev: stack\n      };\n      inArray = Array.isArray(node);\n      keys = inArray ? node : visitorKeys[node.kind] || [];\n      index = -1;\n      edits = [];\n\n      if (parent) {\n        ancestors.push(parent);\n      }\n\n      parent = node;\n    }\n  } while (stack !== undefined);\n\n  if (edits.length !== 0) {\n    newRoot = edits[edits.length - 1][1];\n  }\n\n  return newRoot;\n}\n\nfunction isNode(maybeNode) {\n  return Boolean(maybeNode && typeof maybeNode.kind === 'string');\n}\n/**\n * Creates a new visitor instance which delegates to many visitors to run in\n * parallel. Each visitor will be visited for each node before moving on.\n *\n * If a prior visitor edits a node, no following visitors will see that node.\n */\n\n\nexport function visitInParallel(visitors) {\n  var skipping = new Array(visitors.length);\n  return {\n    enter: function enter(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (!skipping[i]) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          false);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === false) {\n              skipping[i] = node;\n            } else if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined) {\n              return result;\n            }\n          }\n        }\n      }\n    },\n    leave: function leave(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (!skipping[i]) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          true);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined && result !== false) {\n              return result;\n            }\n          }\n        } else if (skipping[i] === node) {\n          skipping[i] = null;\n        }\n      }\n    }\n  };\n}\n/**\n * Creates a new visitor instance which maintains a provided TypeInfo instance\n * along with visiting visitor.\n */\n\nexport function visitWithTypeInfo(typeInfo, visitor) {\n  return {\n    enter: function enter(node) {\n      typeInfo.enter(node);\n      var fn = getVisitFn(visitor, node.kind,\n      /* isLeaving */\n      false);\n\n      if (fn) {\n        var result = fn.apply(visitor, arguments);\n\n        if (result !== undefined) {\n          typeInfo.leave(node);\n\n          if (isNode(result)) {\n            typeInfo.enter(result);\n          }\n        }\n\n        return result;\n      }\n    },\n    leave: function leave(node) {\n      var fn = getVisitFn(visitor, node.kind,\n      /* isLeaving */\n      true);\n      var result;\n\n      if (fn) {\n        result = fn.apply(visitor, arguments);\n      }\n\n      typeInfo.leave(node);\n      return result;\n    }\n  };\n}\n/**\n * Given a visitor instance, if it is leaving or not, and a node kind, return\n * the function the visitor runtime should call.\n */\n\nexport function getVisitFn(visitor, kind, isLeaving) {\n  var kindVisitor = visitor[kind];\n\n  if (kindVisitor) {\n    if (!isLeaving && typeof kindVisitor === 'function') {\n      // { Kind() {} }\n      return kindVisitor;\n    }\n\n    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;\n\n    if (typeof kindSpecificVisitor === 'function') {\n      // { Kind: { enter() {}, leave() {} } }\n      return kindSpecificVisitor;\n    }\n  } else {\n    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;\n\n    if (specificVisitor) {\n      if (typeof specificVisitor === 'function') {\n        // { enter() {}, leave() {} }\n        return specificVisitor;\n      }\n\n      var specificKindVisitor = specificVisitor[kind];\n\n      if (typeof specificKindVisitor === 'function') {\n        // { enter: { Kind() {} }, leave: { Kind() {} } }\n        return specificKindVisitor;\n      }\n    }\n  }\n}\n","var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;\nexport default nodejsCustomInspectSymbol;\n","import { visit } from './visitor';\nimport { printBlockString } from './blockString';\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\n\nexport function print(ast) {\n  return visit(ast, {\n    leave: printDocASTReducer\n  });\n} // TODO: provide better type coverage in future\n\nvar printDocASTReducer = {\n  Name: function Name(node) {\n    return node.value;\n  },\n  Variable: function Variable(node) {\n    return '$' + node.name;\n  },\n  // Document\n  Document: function Document(node) {\n    return join(node.definitions, '\\n\\n') + '\\n';\n  },\n  OperationDefinition: function OperationDefinition(node) {\n    var op = node.operation;\n    var name = node.name;\n    var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');\n    var directives = join(node.directives, ' ');\n    var selectionSet = node.selectionSet; // Anonymous queries with no directives or variable definitions can use\n    // the query short form.\n\n    return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');\n  },\n  VariableDefinition: function VariableDefinition(_ref) {\n    var variable = _ref.variable,\n        type = _ref.type,\n        defaultValue = _ref.defaultValue,\n        directives = _ref.directives;\n    return variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' '));\n  },\n  SelectionSet: function SelectionSet(_ref2) {\n    var selections = _ref2.selections;\n    return block(selections);\n  },\n  Field: function Field(_ref3) {\n    var alias = _ref3.alias,\n        name = _ref3.name,\n        args = _ref3.arguments,\n        directives = _ref3.directives,\n        selectionSet = _ref3.selectionSet;\n    return join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], ' ');\n  },\n  Argument: function Argument(_ref4) {\n    var name = _ref4.name,\n        value = _ref4.value;\n    return name + ': ' + value;\n  },\n  // Fragments\n  FragmentSpread: function FragmentSpread(_ref5) {\n    var name = _ref5.name,\n        directives = _ref5.directives;\n    return '...' + name + wrap(' ', join(directives, ' '));\n  },\n  InlineFragment: function InlineFragment(_ref6) {\n    var typeCondition = _ref6.typeCondition,\n        directives = _ref6.directives,\n        selectionSet = _ref6.selectionSet;\n    return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');\n  },\n  FragmentDefinition: function FragmentDefinition(_ref7) {\n    var name = _ref7.name,\n        typeCondition = _ref7.typeCondition,\n        variableDefinitions = _ref7.variableDefinitions,\n        directives = _ref7.directives,\n        selectionSet = _ref7.selectionSet;\n    return (// Note: fragment variable definitions are experimental and may be changed\n      // or removed in the future.\n      \"fragment \".concat(name).concat(wrap('(', join(variableDefinitions, ', '), ')'), \" \") + \"on \".concat(typeCondition, \" \").concat(wrap('', join(directives, ' '), ' ')) + selectionSet\n    );\n  },\n  // Value\n  IntValue: function IntValue(_ref8) {\n    var value = _ref8.value;\n    return value;\n  },\n  FloatValue: function FloatValue(_ref9) {\n    var value = _ref9.value;\n    return value;\n  },\n  StringValue: function StringValue(_ref10, key) {\n    var value = _ref10.value,\n        isBlockString = _ref10.block;\n    return isBlockString ? printBlockString(value, key === 'description' ? '' : '  ') : JSON.stringify(value);\n  },\n  BooleanValue: function BooleanValue(_ref11) {\n    var value = _ref11.value;\n    return value ? 'true' : 'false';\n  },\n  NullValue: function NullValue() {\n    return 'null';\n  },\n  EnumValue: function EnumValue(_ref12) {\n    var value = _ref12.value;\n    return value;\n  },\n  ListValue: function ListValue(_ref13) {\n    var values = _ref13.values;\n    return '[' + join(values, ', ') + ']';\n  },\n  ObjectValue: function ObjectValue(_ref14) {\n    var fields = _ref14.fields;\n    return '{' + join(fields, ', ') + '}';\n  },\n  ObjectField: function ObjectField(_ref15) {\n    var name = _ref15.name,\n        value = _ref15.value;\n    return name + ': ' + value;\n  },\n  // Directive\n  Directive: function Directive(_ref16) {\n    var name = _ref16.name,\n        args = _ref16.arguments;\n    return '@' + name + wrap('(', join(args, ', '), ')');\n  },\n  // Type\n  NamedType: function NamedType(_ref17) {\n    var name = _ref17.name;\n    return name;\n  },\n  ListType: function ListType(_ref18) {\n    var type = _ref18.type;\n    return '[' + type + ']';\n  },\n  NonNullType: function NonNullType(_ref19) {\n    var type = _ref19.type;\n    return type + '!';\n  },\n  // Type System Definitions\n  SchemaDefinition: function SchemaDefinition(_ref20) {\n    var directives = _ref20.directives,\n        operationTypes = _ref20.operationTypes;\n    return join(['schema', join(directives, ' '), block(operationTypes)], ' ');\n  },\n  OperationTypeDefinition: function OperationTypeDefinition(_ref21) {\n    var operation = _ref21.operation,\n        type = _ref21.type;\n    return operation + ': ' + type;\n  },\n  ScalarTypeDefinition: addDescription(function (_ref22) {\n    var name = _ref22.name,\n        directives = _ref22.directives;\n    return join(['scalar', name, join(directives, ' ')], ' ');\n  }),\n  ObjectTypeDefinition: addDescription(function (_ref23) {\n    var name = _ref23.name,\n        interfaces = _ref23.interfaces,\n        directives = _ref23.directives,\n        fields = _ref23.fields;\n    return join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');\n  }),\n  FieldDefinition: addDescription(function (_ref24) {\n    var name = _ref24.name,\n        args = _ref24.arguments,\n        type = _ref24.type,\n        directives = _ref24.directives;\n    return name + (hasMultilineItems(args) ? wrap('(\\n', indent(join(args, '\\n')), '\\n)') : wrap('(', join(args, ', '), ')')) + ': ' + type + wrap(' ', join(directives, ' '));\n  }),\n  InputValueDefinition: addDescription(function (_ref25) {\n    var name = _ref25.name,\n        type = _ref25.type,\n        defaultValue = _ref25.defaultValue,\n        directives = _ref25.directives;\n    return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');\n  }),\n  InterfaceTypeDefinition: addDescription(function (_ref26) {\n    var name = _ref26.name,\n        directives = _ref26.directives,\n        fields = _ref26.fields;\n    return join(['interface', name, join(directives, ' '), block(fields)], ' ');\n  }),\n  UnionTypeDefinition: addDescription(function (_ref27) {\n    var name = _ref27.name,\n        directives = _ref27.directives,\n        types = _ref27.types;\n    return join(['union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');\n  }),\n  EnumTypeDefinition: addDescription(function (_ref28) {\n    var name = _ref28.name,\n        directives = _ref28.directives,\n        values = _ref28.values;\n    return join(['enum', name, join(directives, ' '), block(values)], ' ');\n  }),\n  EnumValueDefinition: addDescription(function (_ref29) {\n    var name = _ref29.name,\n        directives = _ref29.directives;\n    return join([name, join(directives, ' ')], ' ');\n  }),\n  InputObjectTypeDefinition: addDescription(function (_ref30) {\n    var name = _ref30.name,\n        directives = _ref30.directives,\n        fields = _ref30.fields;\n    return join(['input', name, join(directives, ' '), block(fields)], ' ');\n  }),\n  DirectiveDefinition: addDescription(function (_ref31) {\n    var name = _ref31.name,\n        args = _ref31.arguments,\n        repeatable = _ref31.repeatable,\n        locations = _ref31.locations;\n    return 'directive @' + name + (hasMultilineItems(args) ? wrap('(\\n', indent(join(args, '\\n')), '\\n)') : wrap('(', join(args, ', '), ')')) + (repeatable ? ' repeatable' : '') + ' on ' + join(locations, ' | ');\n  }),\n  SchemaExtension: function SchemaExtension(_ref32) {\n    var directives = _ref32.directives,\n        operationTypes = _ref32.operationTypes;\n    return join(['extend schema', join(directives, ' '), block(operationTypes)], ' ');\n  },\n  ScalarTypeExtension: function ScalarTypeExtension(_ref33) {\n    var name = _ref33.name,\n        directives = _ref33.directives;\n    return join(['extend scalar', name, join(directives, ' ')], ' ');\n  },\n  ObjectTypeExtension: function ObjectTypeExtension(_ref34) {\n    var name = _ref34.name,\n        interfaces = _ref34.interfaces,\n        directives = _ref34.directives,\n        fields = _ref34.fields;\n    return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');\n  },\n  InterfaceTypeExtension: function InterfaceTypeExtension(_ref35) {\n    var name = _ref35.name,\n        directives = _ref35.directives,\n        fields = _ref35.fields;\n    return join(['extend interface', name, join(directives, ' '), block(fields)], ' ');\n  },\n  UnionTypeExtension: function UnionTypeExtension(_ref36) {\n    var name = _ref36.name,\n        directives = _ref36.directives,\n        types = _ref36.types;\n    return join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');\n  },\n  EnumTypeExtension: function EnumTypeExtension(_ref37) {\n    var name = _ref37.name,\n        directives = _ref37.directives,\n        values = _ref37.values;\n    return join(['extend enum', name, join(directives, ' '), block(values)], ' ');\n  },\n  InputObjectTypeExtension: function InputObjectTypeExtension(_ref38) {\n    var name = _ref38.name,\n        directives = _ref38.directives,\n        fields = _ref38.fields;\n    return join(['extend input', name, join(directives, ' '), block(fields)], ' ');\n  }\n};\n\nfunction addDescription(cb) {\n  return function (node) {\n    return join([node.description, cb(node)], '\\n');\n  };\n}\n/**\n * Given maybeArray, print an empty string if it is null or empty, otherwise\n * print all items together separated by separator if provided\n */\n\n\nfunction join(maybeArray, separator) {\n  return maybeArray ? maybeArray.filter(function (x) {\n    return x;\n  }).join(separator || '') : '';\n}\n/**\n * Given array, print each item on its own line, wrapped in an\n * indented \"{ }\" block.\n */\n\n\nfunction block(array) {\n  return array && array.length !== 0 ? '{\\n' + indent(join(array, '\\n')) + '\\n}' : '';\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise\n * print an empty string.\n */\n\n\nfunction wrap(start, maybeString, end) {\n  return maybeString ? start + maybeString + (end || '') : '';\n}\n\nfunction indent(maybeString) {\n  return maybeString && '  ' + maybeString.replace(/\\n/g, '\\n  ');\n}\n\nfunction isMultiline(string) {\n  return string.indexOf('\\n') !== -1;\n}\n\nfunction hasMultilineItems(maybeArray) {\n  return maybeArray && maybeArray.some(isMultiline);\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var parser = require('graphql/language/parser');\n\nvar parse = parser.parse;\n\n// Strip insignificant whitespace\n// Note that this could do a lot more, such as reorder fields etc.\nfunction normalize(string) {\n  return string.replace(/[\\s,]+/g, ' ').trim();\n}\n\n// A map docString -> graphql document\nvar docCache = {};\n\n// A map fragmentName -> [normalized source]\nvar fragmentSourceMap = {};\n\nfunction cacheKeyFromLoc(loc) {\n  return normalize(loc.source.body.substring(loc.start, loc.end));\n}\n\n// For testing.\nfunction resetCaches() {\n  docCache = {};\n  fragmentSourceMap = {};\n}\n\n// Take a unstripped parsed document (query/mutation or even fragment), and\n// check all fragment definitions, checking for name->source uniqueness.\n// We also want to make sure only unique fragments exist in the document.\nvar printFragmentWarnings = true;\nfunction processFragments(ast) {\n  var astFragmentMap = {};\n  var definitions = [];\n\n  for (var i = 0; i < ast.definitions.length; i++) {\n    var fragmentDefinition = ast.definitions[i];\n\n    if (fragmentDefinition.kind === 'FragmentDefinition') {\n      var fragmentName = fragmentDefinition.name.value;\n      var sourceKey = cacheKeyFromLoc(fragmentDefinition.loc);\n\n      // We know something about this fragment\n      if (fragmentSourceMap.hasOwnProperty(fragmentName) && !fragmentSourceMap[fragmentName][sourceKey]) {\n\n        // this is a problem because the app developer is trying to register another fragment with\n        // the same name as one previously registered. So, we tell them about it.\n        if (printFragmentWarnings) {\n          console.warn(\"Warning: fragment with name \" + fragmentName + \" already exists.\\n\"\n            + \"graphql-tag enforces all fragment names across your application to be unique; read more about\\n\"\n            + \"this in the docs: http://dev.apollodata.com/core/fragments.html#unique-names\");\n        }\n\n        fragmentSourceMap[fragmentName][sourceKey] = true;\n\n      } else if (!fragmentSourceMap.hasOwnProperty(fragmentName)) {\n        fragmentSourceMap[fragmentName] = {};\n        fragmentSourceMap[fragmentName][sourceKey] = true;\n      }\n\n      if (!astFragmentMap[sourceKey]) {\n        astFragmentMap[sourceKey] = true;\n        definitions.push(fragmentDefinition);\n      }\n    } else {\n      definitions.push(fragmentDefinition);\n    }\n  }\n\n  ast.definitions = definitions;\n  return ast;\n}\n\nfunction disableFragmentWarnings() {\n  printFragmentWarnings = false;\n}\n\nfunction stripLoc(doc, removeLocAtThisLevel) {\n  var docType = Object.prototype.toString.call(doc);\n\n  if (docType === '[object Array]') {\n    return doc.map(function (d) {\n      return stripLoc(d, removeLocAtThisLevel);\n    });\n  }\n\n  if (docType !== '[object Object]') {\n    throw new Error('Unexpected input.');\n  }\n\n  // We don't want to remove the root loc field so we can use it\n  // for fragment substitution (see below)\n  if (removeLocAtThisLevel && doc.loc) {\n    delete doc.loc;\n  }\n\n  // https://github.com/apollographql/graphql-tag/issues/40\n  if (doc.loc) {\n    delete doc.loc.startToken;\n    delete doc.loc.endToken;\n  }\n\n  var keys = Object.keys(doc);\n  var key;\n  var value;\n  var valueType;\n\n  for (key in keys) {\n    if (keys.hasOwnProperty(key)) {\n      value = doc[keys[key]];\n      valueType = Object.prototype.toString.call(value);\n\n      if (valueType === '[object Object]' || valueType === '[object Array]') {\n        doc[keys[key]] = stripLoc(value, true);\n      }\n    }\n  }\n\n  return doc;\n}\n\nvar experimentalFragmentVariables = false;\nfunction parseDocument(doc) {\n  var cacheKey = normalize(doc);\n\n  if (docCache[cacheKey]) {\n    return docCache[cacheKey];\n  }\n\n  var parsed = parse(doc, { experimentalFragmentVariables: experimentalFragmentVariables });\n  if (!parsed || parsed.kind !== 'Document') {\n    throw new Error('Not a valid GraphQL document.');\n  }\n\n  // check that all \"new\" fragments inside the documents are consistent with\n  // existing fragments of the same name\n  parsed = processFragments(parsed);\n  parsed = stripLoc(parsed, false);\n  docCache[cacheKey] = parsed;\n\n  return parsed;\n}\n\nfunction enableExperimentalFragmentVariables() {\n  experimentalFragmentVariables = true;\n}\n\nfunction disableExperimentalFragmentVariables() {\n  experimentalFragmentVariables = false;\n}\n\n// XXX This should eventually disallow arbitrary string interpolation, like Relay does\nfunction gql(/* arguments */) {\n  var args = Array.prototype.slice.call(arguments);\n\n  var literals = args[0];\n\n  // We always get literals[0] and then matching post literals for each arg given\n  var result = (typeof(literals) === \"string\") ? literals : literals[0];\n\n  for (var i = 1; i < args.length; i++) {\n    if (args[i] && args[i].kind && args[i].kind === 'Document') {\n      result += args[i].loc.source.body;\n    } else {\n      result += args[i];\n    }\n\n    result += literals[i];\n  }\n\n  return parseDocument(result);\n}\n\n// Support typescript, which isn't as nice as Babel about default exports\ngql.default = gql;\ngql.resetCaches = resetCaches;\ngql.disableFragmentWarnings = disableFragmentWarnings;\ngql.enableExperimentalFragmentVariables = enableExperimentalFragmentVariables;\ngql.disableExperimentalFragmentVariables = disableExperimentalFragmentVariables;\n\nmodule.exports = gql;\n","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nimport nodejsCustomInspectSymbol from './nodejsCustomInspectSymbol';\nvar MAX_ARRAY_LENGTH = 10;\nvar MAX_RECURSIVE_DEPTH = 2;\n/**\n * Used to print values in error messages.\n */\n\nexport default function inspect(value) {\n  return formatValue(value, []);\n}\n\nfunction formatValue(value, seenValues) {\n  switch (_typeof(value)) {\n    case 'string':\n      return JSON.stringify(value);\n\n    case 'function':\n      return value.name ? \"[function \".concat(value.name, \"]\") : '[function]';\n\n    case 'object':\n      if (value === null) {\n        return 'null';\n      }\n\n      return formatObjectValue(value, seenValues);\n\n    default:\n      return String(value);\n  }\n}\n\nfunction formatObjectValue(value, previouslySeenValues) {\n  if (previouslySeenValues.indexOf(value) !== -1) {\n    return '[Circular]';\n  }\n\n  var seenValues = [].concat(previouslySeenValues, [value]);\n  var customInspectFn = getCustomFn(value);\n\n  if (customInspectFn !== undefined) {\n    // $FlowFixMe(>=0.90.0)\n    var customValue = customInspectFn.call(value); // check for infinite recursion\n\n    if (customValue !== value) {\n      return typeof customValue === 'string' ? customValue : formatValue(customValue, seenValues);\n    }\n  } else if (Array.isArray(value)) {\n    return formatArray(value, seenValues);\n  }\n\n  return formatObject(value, seenValues);\n}\n\nfunction formatObject(object, seenValues) {\n  var keys = Object.keys(object);\n\n  if (keys.length === 0) {\n    return '{}';\n  }\n\n  if (seenValues.length > MAX_RECURSIVE_DEPTH) {\n    return '[' + getObjectTag(object) + ']';\n  }\n\n  var properties = keys.map(function (key) {\n    var value = formatValue(object[key], seenValues);\n    return key + ': ' + value;\n  });\n  return '{ ' + properties.join(', ') + ' }';\n}\n\nfunction formatArray(array, seenValues) {\n  if (array.length === 0) {\n    return '[]';\n  }\n\n  if (seenValues.length > MAX_RECURSIVE_DEPTH) {\n    return '[Array]';\n  }\n\n  var len = Math.min(MAX_ARRAY_LENGTH, array.length);\n  var remaining = array.length - len;\n  var items = [];\n\n  for (var i = 0; i < len; ++i) {\n    items.push(formatValue(array[i], seenValues));\n  }\n\n  if (remaining === 1) {\n    items.push('... 1 more item');\n  } else if (remaining > 1) {\n    items.push(\"... \".concat(remaining, \" more items\"));\n  }\n\n  return '[' + items.join(', ') + ']';\n}\n\nfunction getCustomFn(object) {\n  var customInspectFn = object[String(nodejsCustomInspectSymbol)];\n\n  if (typeof customInspectFn === 'function') {\n    return customInspectFn;\n  }\n\n  if (typeof object.inspect === 'function') {\n    return object.inspect;\n  }\n}\n\nfunction getObjectTag(object) {\n  var tag = Object.prototype.toString.call(object).replace(/^\\[object /, '').replace(/]$/, '');\n\n  if (tag === 'Object' && typeof object.constructor === 'function') {\n    var name = object.constructor.name;\n\n    if (typeof name === 'string' && name !== '') {\n      return name;\n    }\n  }\n\n  return tag;\n}\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n"],"sourceRoot":""}