{"version":3,"sources":["../../../node_modules/prop-types/index.js","../../../node_modules/process/browser.js","../../../node_modules/graphql/language/printer.js","../../../node_modules/fast-deep-equal/index.js","../../../node_modules/memoize-one/dist/memoize-one.esm.js","../../../node_modules/object-assign/index.js","../../../node_modules/os-browserify/browser.js","../../../node_modules/fast-json-stable-stringify/index.js","../../../node_modules/graphql/jsutils/inspect.js","../../../node_modules/graphql/language/blockString.js","../../../node_modules/graphql/jsutils/nodejsCustomInspectSymbol.js","../../../node_modules/path-browserify/index.js","../../../node_modules/graphql/language/visitor.js","../../../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","../../../node_modules/is-html/index.js","../../../node_modules/is-html/node_modules/html-tags/index.js","../../../node_modules/prop-types/factoryWithThrowingShims.js","../../../node_modules/prop-types/lib/ReactPropTypesSecret.js","../../../node_modules/fast-deep-equal/react.js","../../../node_modules/pp-react-l10n/dist/pp-react-l10n.esm.js","../../../node_modules/optimism/node_modules/@wry/context/lib/context.esm.js","../../../node_modules/optimism/lib/bundle.esm.js"],"names":["module","exports","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","e","call","this","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","length","concat","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","Array","arguments","i","push","prototype","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","name","binding","cwd","chdir","dir","umask","Object","defineProperty","value","print","ast","_visitor","visit","leave","printDocASTReducer","_blockString","Name","node","Variable","Document","join","definitions","OperationDefinition","op","operation","varDefs","wrap","variableDefinitions","directives","selectionSet","VariableDefinition","_ref","variable","type","defaultValue","SelectionSet","_ref2","block","selections","Field","_ref3","alias","Argument","_ref4","FragmentSpread","_ref5","InlineFragment","_ref6","typeCondition","FragmentDefinition","_ref7","IntValue","_ref8","FloatValue","_ref9","StringValue","_ref10","key","printBlockString","JSON","stringify","BooleanValue","_ref11","NullValue","EnumValue","_ref12","ListValue","_ref13","values","ObjectValue","_ref14","fields","ObjectField","_ref15","Directive","_ref16","NamedType","_ref17","ListType","_ref18","NonNullType","_ref19","SchemaDefinition","_ref20","operationTypes","OperationTypeDefinition","_ref21","ScalarTypeDefinition","addDescription","_ref22","ObjectTypeDefinition","_ref23","interfaces","FieldDefinition","_ref24","hasMultilineItems","indent","InputValueDefinition","_ref25","InterfaceTypeDefinition","_ref26","UnionTypeDefinition","_ref27","types","EnumTypeDefinition","_ref28","EnumValueDefinition","_ref29","InputObjectTypeDefinition","_ref30","DirectiveDefinition","_ref31","repeatable","locations","SchemaExtension","_ref32","ScalarTypeExtension","_ref33","ObjectTypeExtension","_ref34","InterfaceTypeExtension","_ref35","UnionTypeExtension","_ref36","EnumTypeExtension","_ref37","InputObjectTypeExtension","_ref38","cb","description","maybeArray","separator","filter","x","start","maybeString","end","replace","isMultiline","string","indexOf","some","equal","a","b","constructor","keys","isArray","RegExp","source","flags","valueOf","toString","hasOwnProperty","areInputsEqual","newInputs","lastInputs","resultFn","isEqual","lastThis","lastResult","lastArgs","calledOnce","newArgs","_i","getOwnPropertySymbols","propIsEnumerable","propertyIsEnumerable","toObject","val","undefined","TypeError","assign","test1","String","getOwnPropertyNames","test2","fromCharCode","map","n","test3","split","forEach","letter","err","shouldUseNative","target","from","symbols","to","s","endianness","hostname","location","loadavg","uptime","freemem","Number","MAX_VALUE","totalmem","cpus","release","navigator","appVersion","networkInterfaces","getNetworkInterfaces","arch","platform","tmpdir","tmpDir","EOL","homedir","data","opts","cmp","f","cycles","aobj","bobj","seen","toJSON","isFinite","out","seenIndex","sort","splice","default","formatValue","obj","_nodejsCustomInspectSymbol","__esModule","_typeof","Symbol","iterator","seenValues","previouslySeenValues","customInspectFn","object","inspect","getCustomFn","customValue","Math","min","remaining","items","formatArray","tag","getObjectTag","formatObject","formatObjectValue","getBlockStringIndentation","lines","commonIndent","line","leadingWhitespace","str","isBlank","dedentBlockStringValue","rawString","slice","shift","pop","indentation","preferMultipleLines","isSingleLine","hasLeadingSpace","hasTrailingQuote","printAsMultipleLines","result","_default","for","normalizeArray","parts","allowAboveRoot","up","last","unshift","xs","res","resolve","resolvedPath","resolvedAbsolute","path","charAt","p","normalize","isAbsolute","trailingSlash","substr","paths","index","relative","trim","arr","fromParts","toParts","samePartsLength","outputParts","sep","delimiter","dirname","code","charCodeAt","hasRoot","matchedSlash","basename","ext","extname","startDot","startPart","preDotState","root","visitor","visitorKeys","QueryDocumentKeys","stack","inArray","edits","parent","ancestors","newRoot","isLeaving","isEdited","clone","_i2","_Object$keys2","k","editOffset","ii","editKey","editValue","prev","isNode","_inspect","visitFn","getVisitFn","kind","BREAK","visitInParallel","visitors","skipping","enter","fn","visitWithTypeInfo","typeInfo","freeze","maybeNode","Boolean","kindVisitor","kindSpecificVisitor","specificVisitor","specificKindVisitor","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","KNOWN_STATICS","caller","callee","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","getOwnPropertyDescriptor","getPrototypeOf","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","descriptor","htmlTags","basic","full","el","test","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","props","propName","componentName","propFullName","secret","getShim","isRequired","ReactPropTypes","bool","func","number","symbol","any","arrayOf","element","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","$$typeof","_defineProperty","enumerable","configurable","writable","_objectSpread","ownKeys","sym","_slicedToArray","_arrayWithHoles","_arr","_n","_d","_e","_s","next","done","_iterableToArrayLimit","_nonIterableRest","commonjsGlobal","window","global","self","symbolTag","reUnescapedHtml","reHasUnescapedHtml","freeGlobal","freeSelf","Function","escapeHtmlChar","objectToString","Symbol$1","symbolProto","symbolToString","baseToString","isObjectLike","isSymbol","lodash_escape","oget","def","reduce","curr","logger","log","bind","warn","error","info","globalContent","status","complete","logWarnings","postponeWarnings","setComplete","internalGetContent","ITERATOR_SYMBOL","onContentMissingNoop","getContent","options","_options$content","content","_options$onContentMis","onContentMissing","getCurriedGetContent","retrievedContent","c","getReactContent","ppReactL10nGetContent","incomingOptions","pathAsString","html","useHTML","timesCalled","resultAtPath","method","contentString","__html","interpolatedContent","chunk","match","isValidElement","keyifyReactElements","joinedContent","every","createElement","dangerouslySetInnerHTML","init","_options$contentNode","contentNode","document","getElementById","logContentMissing","getContentFromNode","innerHTML","parse","currentContext","MISSING_VALUE","idCounter","globalKey","host","Slot","id","Date","now","random","hasValue","context_1","slots","getValue","withValue","callback","thisArg","_a","__proto__","context","saved","noContext","defaultDispose","Cache","max","dispose","Infinity","Map","newest","oldest","has","get","entry","getEntry","older","newer","set","clean","size","delete","parentEntrySlot","reusableEmptyArray","emptySetPool","assert","condition","optionalMessage","valueGet","Entry","parents","Set","childValues","dirtyChildren","dirty","recomputing","count","recompute","child","add","mightBeDirty","reportDirtyChild","reportCleanChild","rememberParent","maybeReportOrphan","originalChildren","forgetChildren","recomputeNewValue","subscribe","maybeUnsubscribe","unsubscribe","setDirty","maybeSubscribe","reportClean","setClean","reallyRecompute","reportDirty","_this","forgetChild","childValue","valueIs","removeDirtyChild","dc","reportOrphan","children","_value","KeyTrie","weakness","lookup","lookupArray","getChildTrie","create","isObjRef","weak","WeakMap","strong","keyTrie","defaultMakeCacheKey","caches","originalFunction","cache","pow","disposable","makeCacheKey","optimistic","clear"],"mappings":"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","file":"js/vendors~main~361f037c.c7eac57c.js","sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is'); // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n\n\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}","// shim for using process in browser\nvar process = module.exports = {}; // cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n\n(function () {\n  try {\n    if (typeof setTimeout === 'function') {\n      cachedSetTimeout = setTimeout;\n    } else {\n      cachedSetTimeout = defaultSetTimout;\n    }\n  } catch (e) {\n    cachedSetTimeout = defaultSetTimout;\n  }\n\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\n\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\n\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\n\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n  var args = new Array(arguments.length - 1);\n\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n}; // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\n\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n  return [];\n};\n\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n  return '/';\n};\n\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\n\nprocess.umask = function () {\n  return 0;\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.print = print;\n\nvar _visitor = require(\"./visitor\");\n\nvar _blockString = require(\"./blockString\");\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\n\n\nfunction print(ast) {\n  return (0, _visitor.visit)(ast, {\n    leave: printDocASTReducer\n  });\n} // TODO: provide better type coverage in future\n\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 ? (0, _blockString.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}","'use strict'; // do not edit .js files directly - edit src/index.jst\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n    var length, i, keys;\n\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n\n      for (i = length; i-- !== 0;) {\n        if (!equal(a[i], b[i])) return false;\n      }\n\n      return true;\n    }\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;) {\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    }\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  } // true if both NaN, false otherwise\n\n\n  return a !== a && b !== b;\n};","function areInputsEqual(newInputs, lastInputs) {\n  if (newInputs.length !== lastInputs.length) {\n    return false;\n  }\n\n  for (var i = 0; i < newInputs.length; i++) {\n    if (newInputs[i] !== lastInputs[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n  if (isEqual === void 0) {\n    isEqual = areInputsEqual;\n  }\n\n  var lastThis;\n  var lastArgs = [];\n  var lastResult;\n  var calledOnce = false;\n\n  function memoized() {\n    var newArgs = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      newArgs[_i] = arguments[_i];\n    }\n\n    if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {\n      return lastResult;\n    }\n\n    lastResult = resultFn.apply(this, newArgs);\n    calledOnce = true;\n    lastThis = this;\n    lastArgs = newArgs;\n    return lastResult;\n  }\n\n  return memoized;\n}\n\nexport default memoizeOne;","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n'use strict';\n/* eslint-disable no-unused-vars */\n\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n  if (val === null || val === undefined) {\n    throw new TypeError('Object.assign cannot be called with null or undefined');\n  }\n\n  return Object(val);\n}\n\nfunction shouldUseNative() {\n  try {\n    if (!Object.assign) {\n      return false;\n    } // Detect buggy property enumeration order in older V8 versions.\n    // https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\n\n    var test1 = new String('abc'); // eslint-disable-line no-new-wrappers\n\n    test1[5] = 'de';\n\n    if (Object.getOwnPropertyNames(test1)[0] === '5') {\n      return false;\n    } // https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\n\n    var test2 = {};\n\n    for (var i = 0; i < 10; i++) {\n      test2['_' + String.fromCharCode(i)] = i;\n    }\n\n    var order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n      return test2[n];\n    });\n\n    if (order2.join('') !== '0123456789') {\n      return false;\n    } // https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\n\n    var test3 = {};\n    'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n      test3[letter] = letter;\n    });\n\n    if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') {\n      return false;\n    }\n\n    return true;\n  } catch (err) {\n    // We don't expect any of the above to throw, but better to be safe.\n    return false;\n  }\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n  var from;\n  var to = toObject(target);\n  var symbols;\n\n  for (var s = 1; s < arguments.length; s++) {\n    from = Object(arguments[s]);\n\n    for (var key in from) {\n      if (hasOwnProperty.call(from, key)) {\n        to[key] = from[key];\n      }\n    }\n\n    if (getOwnPropertySymbols) {\n      symbols = getOwnPropertySymbols(from);\n\n      for (var i = 0; i < symbols.length; i++) {\n        if (propIsEnumerable.call(from, symbols[i])) {\n          to[symbols[i]] = from[symbols[i]];\n        }\n      }\n    }\n  }\n\n  return to;\n};","exports.endianness = function () {\n  return 'LE';\n};\n\nexports.hostname = function () {\n  if (typeof location !== 'undefined') {\n    return location.hostname;\n  } else return '';\n};\n\nexports.loadavg = function () {\n  return [];\n};\n\nexports.uptime = function () {\n  return 0;\n};\n\nexports.freemem = function () {\n  return Number.MAX_VALUE;\n};\n\nexports.totalmem = function () {\n  return Number.MAX_VALUE;\n};\n\nexports.cpus = function () {\n  return [];\n};\n\nexports.type = function () {\n  return 'Browser';\n};\n\nexports.release = function () {\n  if (typeof navigator !== 'undefined') {\n    return navigator.appVersion;\n  }\n\n  return '';\n};\n\nexports.networkInterfaces = exports.getNetworkInterfaces = function () {\n  return {};\n};\n\nexports.arch = function () {\n  return 'javascript';\n};\n\nexports.platform = function () {\n  return 'browser';\n};\n\nexports.tmpdir = exports.tmpDir = function () {\n  return '/tmp';\n};\n\nexports.EOL = '\\n';\n\nexports.homedir = function () {\n  return '/';\n};","'use strict';\n\nmodule.exports = function (data, opts) {\n  if (!opts) opts = {};\n  if (typeof opts === 'function') opts = {\n    cmp: opts\n  };\n  var cycles = typeof opts.cycles === 'boolean' ? opts.cycles : false;\n\n  var cmp = opts.cmp && function (f) {\n    return function (node) {\n      return function (a, b) {\n        var aobj = {\n          key: a,\n          value: node[a]\n        };\n        var bobj = {\n          key: b,\n          value: node[b]\n        };\n        return f(aobj, bobj);\n      };\n    };\n  }(opts.cmp);\n\n  var seen = [];\n  return function stringify(node) {\n    if (node && node.toJSON && typeof node.toJSON === 'function') {\n      node = node.toJSON();\n    }\n\n    if (node === undefined) return;\n    if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';\n    if (typeof node !== 'object') return JSON.stringify(node);\n    var i, out;\n\n    if (Array.isArray(node)) {\n      out = '[';\n\n      for (i = 0; i < node.length; i++) {\n        if (i) out += ',';\n        out += stringify(node[i]) || 'null';\n      }\n\n      return out + ']';\n    }\n\n    if (node === null) return 'null';\n\n    if (seen.indexOf(node) !== -1) {\n      if (cycles) return JSON.stringify('__cycle__');\n      throw new TypeError('Converting circular structure to JSON');\n    }\n\n    var seenIndex = seen.push(node) - 1;\n    var keys = Object.keys(node).sort(cmp && cmp(node));\n    out = '';\n\n    for (i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      var value = stringify(node[key]);\n      if (!value) continue;\n      if (out) out += ',';\n      out += JSON.stringify(key) + ':' + value;\n    }\n\n    seen.splice(seenIndex, 1);\n    return '{' + out + '}';\n  }(data);\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = inspect;\n\nvar _nodejsCustomInspectSymbol = _interopRequireDefault(require(\"./nodejsCustomInspectSymbol\"));\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    default: obj\n  };\n}\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nvar MAX_ARRAY_LENGTH = 10;\nvar MAX_RECURSIVE_DEPTH = 2;\n/**\n * Used to print values in error messages.\n */\n\nfunction 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.default)];\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}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.dedentBlockStringValue = dedentBlockStringValue;\nexports.getBlockStringIndentation = getBlockStringIndentation;\nexports.printBlockString = printBlockString;\n/**\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 */\n\nfunction 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\n\nfunction 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\nfunction 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}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;\nvar _default = nodejsCustomInspectSymbol;\nexports.default = _default;","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  } // if the path is allowed to go above the root, restore leading ..s\n\n\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n} // path.resolve([from ...], to)\n// posix version\n\n\nexports.resolve = function () {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = i >= 0 ? arguments[i] : process.cwd(); // Skip empty and invalid entries\n\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  } // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n  // Normalize the path\n\n\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function (p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}; // path.normalize(path)\n// posix version\n\n\nexports.normalize = function (path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/'; // Normalize the path\n\n  path = normalizeArray(filter(path.split('/'), function (p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n}; // posix version\n\n\nexports.isAbsolute = function (path) {\n  return path.charAt(0) === '/';\n}; // posix version\n\n\nexports.join = function () {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function (p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n\n    return p;\n  }).join('/'));\n}; // path.relative(from, to)\n// posix version\n\n\nexports.relative = function (from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47\n  /*/*/\n  ;\n  var end = -1;\n  var matchedSlash = true;\n\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n\n    if (code === 47\n    /*/*/\n    ) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47\n    /*/*/\n    ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n} // Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\n\n\nexports.basename = function (path, ext) {\n  var f = basename(path);\n\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true; // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n\n  var preDotState = 0;\n\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n\n    if (code === 47\n    /*/*/\n    ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n\n        continue;\n      }\n\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n\n    if (code === 46\n    /*.*/\n    ) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n      } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot\n  preDotState === 0 || // The (right-most) trimmed path component is exactly '..'\n  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n\n  return path.slice(startDot, end);\n};\n\nfunction filter(xs, f) {\n  if (xs.filter) return xs.filter(f);\n  var res = [];\n\n  for (var i = 0; i < xs.length; i++) {\n    if (f(xs[i], i, xs)) res.push(xs[i]);\n  }\n\n  return res;\n} // String.prototype.substr - negative index don't work in IE8\n\n\nvar substr = 'ab'.substr(-1) === 'b' ? function (str, start, len) {\n  return str.substr(start, len);\n} : function (str, start, len) {\n  if (start < 0) start = str.length + start;\n  return str.substr(start, len);\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.visit = visit;\nexports.visitInParallel = visitInParallel;\nexports.visitWithTypeInfo = visitWithTypeInfo;\nexports.getVisitFn = getVisitFn;\nexports.BREAK = exports.QueryDocumentKeys = void 0;\n\nvar _inspect = _interopRequireDefault(require(\"../jsutils/inspect\"));\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    default: obj\n  };\n}\n\nvar 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};\nexports.QueryDocumentKeys = QueryDocumentKeys;\nvar 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\nexports.BREAK = BREAK;\n\nfunction visit(root, visitor) {\n  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;\n  /* eslint-disable no-undef-init */\n\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: ' + (0, _inspect.default)(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\nfunction 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\n\nfunction 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\n\nfunction 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}","'use strict';\n\nvar reactIs = require('react-is');\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\n\n\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\n\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;","'use strict';\n\nvar htmlTags = require('html-tags');\n\nvar basic = /\\s?<!doctype html>|(<html\\b[^>]*>|<body\\b[^>]*>|<x-[^>]+>)+/i;\nvar full = new RegExp(htmlTags.map(function (el) {\n  return '<' + el + '\\\\b[^>]*>';\n}).join('|'), 'i');\n\nmodule.exports = function (str) {\n  if (basic.test(str)) {\n    return true;\n  }\n\n  return full.test(str);\n};","module.exports = require('./html-tags.json');","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\n\nfunction emptyFunctionWithReset() {}\n\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function () {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n\n    var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');\n    err.name = 'Invariant Violation';\n    throw err;\n  }\n\n  ;\n  shim.isRequired = shim;\n\n  function getShim() {\n    return shim;\n  }\n\n  ; // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n  ReactPropTypes.PropTypes = ReactPropTypes;\n  return ReactPropTypes;\n};","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\nmodule.exports = ReactPropTypesSecret;","'use strict'; // do not edit .js files directly - edit src/index.jst\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n    var length, i, keys;\n\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n\n      for (i = length; i-- !== 0;) {\n        if (!equal(a[i], b[i])) return false;\n      }\n\n      return true;\n    }\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;) {\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    }\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (key === '_owner' && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner.\n        //  _owner contains circular references\n        // and is not needed when comparing the actual elements (and not their owners)\n        continue;\n      }\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  } // true if both NaN, false otherwise\n\n\n  return a !== a && b !== b;\n};","import React from 'react';\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}\n\nfunction _slicedToArray(arr, i) {\n  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n}\n\nfunction _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nfunction _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n}\n\nvar commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\n\nvar INFINITY = 1 / 0;\n/** `Object#toString` result references. */\n\nvar symbolTag = '[object Symbol]';\n/** Used to match HTML entities and HTML characters. */\n\nvar reUnescapedHtml = /[&<>\"'`]/g,\n    reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n/** Used to map characters to HTML entities. */\n\nvar htmlEscapes = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n  '`': '&#96;'\n};\n/** Detect free variable `global` from Node.js. */\n\nvar freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;\n/** Detect free variable `self`. */\n\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n/** Used as a reference to the global object. */\n\nvar root = freeGlobal || freeSelf || Function('return this')();\n/**\n * The base implementation of `_.propertyOf` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n */\n\nfunction basePropertyOf(object) {\n  return function (key) {\n    return object == null ? undefined : object[key];\n  };\n}\n/**\n * Used by `_.escape` to convert characters to HTML entities.\n *\n * @private\n * @param {string} chr The matched character to escape.\n * @returns {string} Returns the escaped character.\n */\n\n\nvar escapeHtmlChar = basePropertyOf(htmlEscapes);\n/** Used for built-in method references. */\n\nvar objectProto = Object.prototype;\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\n\nvar objectToString = objectProto.toString;\n/** Built-in value references. */\n\nvar Symbol$1 = root.Symbol;\n/** Used to convert symbols to primitives and strings. */\n\nvar symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\n\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n\n  var result = value + '';\n  return result == '0' && 1 / value == -INFINITY ? '-0' : result;\n}\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\n\n\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\n\n\nfunction isSymbol(value) {\n  return typeof value == 'symbol' || isObjectLike(value) && objectToString.call(value) == symbolTag;\n}\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\n\n\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n/**\n * Converts the characters \"&\", \"<\", \">\", '\"', \"'\", and \"\\`\" in `string` to\n * their corresponding HTML entities.\n *\n * **Note:** No other characters are escaped. To escape additional\n * characters use a third-party library like [_he_](https://mths.be/he).\n *\n * Though the \">\" character is escaped for symmetry, characters like\n * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n * unless they're part of a tag or unquoted attribute value. See\n * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n * (under \"semi-related fun fact\") for more details.\n *\n * Backticks are escaped because in IE < 9, they can break out of\n * attribute values or HTML comments. See [#59](https://html5sec.org/#59),\n * [#102](https://html5sec.org/#102), [#108](https://html5sec.org/#108), and\n * [#133](https://html5sec.org/#133) of the\n * [HTML5 Security Cheatsheet](https://html5sec.org/) for more details.\n *\n * When working with HTML you should always\n * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n * XSS vectors.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escape('fred, barney, & pebbles');\n * // => 'fred, barney, &amp; pebbles'\n */\n\n\nfunction escape(string) {\n  string = toString(string);\n  return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;\n}\n\nvar lodash_escape = escape;\n\nvar oget = function oget(obj, path, def) {\n  var res = path.replace(/\\[/g, '.').replace(/\\]/g, '').replace(/^\\./, '').split('.').reduce(function (prev, curr) {\n    return prev && prev[curr];\n  }, obj);\n  return res === undefined ? def : res;\n};\n\nfunction logger(type) {\n  /* istanbul ignore next */\n  if (process.env.NODE_ENV !== 'production' && (typeof window !== 'undefined' && window.console || typeof global !== 'undefined' && global.console)) {\n    var _console;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    } // eslint-disable-next-line no-console\n\n\n    (_console = console)[type].apply(_console, ['[pp-react-l10n]'].concat(args));\n  }\n}\n\nvar log = logger.bind(null, 'log');\nlog.warn = logger.bind(null, 'warn');\nlog.error = logger.bind(null, 'error');\nlog.info = logger.bind(null, 'info'); // this singleton allows content to be loaded asynchronously\n// while still allowing content getters to be initialized\n// and use the global content after content has loaded\n\nvar globalContent = {}; // this allows you to specify that no warnings should be displayed until\n// the init function has been called\n\nvar status = {\n  complete: false,\n  logWarnings: true\n};\n\nfunction postponeWarnings() {\n  status.logWarnings = false;\n}\n\nfunction setComplete() {\n  status.complete = true;\n  status.logWarnings = true;\n}\n/* istanbul ignore next */\n\n\nvar ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator || '@@iterator';\n\nvar onContentMissingNoop = function onContentMissingNoop() {};\n\nfunction getContent() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var path = options.path,\n      _options$content = options.content,\n      content = _options$content === void 0 ? {} : _options$content,\n      _options$onContentMis = options.onContentMissing,\n      onContentMissing = _options$onContentMis === void 0 ? onContentMissingNoop : _options$onContentMis;\n\n  if (!path) {\n    return getCurriedGetContent(options);\n  }\n\n  var retrievedContent = oget(content, path);\n\n  if (!retrievedContent) {\n    onContentMissing(options);\n    return getCurriedGetContent(options);\n  } else if (Array.isArray(retrievedContent)) {\n    return retrievedContent.map(function (c) {\n      return getReactContent(c, options);\n    });\n  } else if (typeof retrievedContent !== 'string') {\n    return getCurriedGetContent(options);\n  }\n\n  return getReactContent(retrievedContent, options);\n}\n\nfunction getCurriedGetContent(options) {\n  // this function is the one folks will use most of the time.\n  // it has a bit nicer API because most of the time people will\n  // only be passing the `path` and `data` so those have been\n  // put at param1 and param2, then the rest of the options are\n  // in param3.\n  function ppReactL10nGetContent(path, data) {\n    var incomingOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    return getContent(_objectSpread({}, options, incomingOptions, {\n      // manually merge these things\n      content: _objectSpread({}, globalContent, options.content, incomingOptions.content),\n      path: [options.path, path].filter(Boolean).join('.'),\n      data: _objectSpread({}, options.data, incomingOptions.data, data)\n    }));\n  }\n\n  var pathAsString = options.path === '' ? '' : \"{\".concat(String(options.path), \"}\"); // flow doesn't like assigning toString on the function...\n  // $FlowIgnore\n\n  Object.assign(ppReactL10nGetContent, _defineProperty({\n    html: function html(path, data) {\n      var incomingOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n      return ppReactL10nGetContent(path, data, _objectSpread({\n        useHTML: true\n      }, incomingOptions));\n    },\n    // these methods ensure that things don't break\n    // when there's a typo or the content doesn't load.\n    toString: function toString() {\n      return pathAsString;\n    } // this is here as an error case.\n    // if the developer attempts to render a content getter, react will\n    // render with this iterator, so we can log an error and have it\n    // render the pathAsString instead\n\n  }, ITERATOR_SYMBOL, function () {\n    var timesCalled = 0;\n    var resultAtPath = oget(options.content, options.path);\n\n    if (status.logWarnings) {\n      log.error('An attempt was made to render a content getter function.', // eslint-disable-next-line no-nested-ternary\n      !options.path ? 'This is because no path was provided' : resultAtPath ? \"This is because the content at path \\\"\".concat(String(options.path), \"\\\" is not a string\") : \"This is because there is no content at the path \\\"\".concat(String(options.path), \"\\\"\"), {\n        resultAtPath: resultAtPath,\n        options: options\n      });\n    }\n\n    return {\n      next: function next() {\n        return {\n          done: timesCalled++ > 0,\n          value: pathAsString\n        };\n      }\n    };\n  })); // prevent app from crashing when expecting content to be an array\n  // but there is a typo or the content failed to load\n\n  Object.getOwnPropertyNames(Array.prototype).forEach(function (method) {\n    // flow doesn't like this for some reason...\n    // $FlowIgnore\n    if (Array.prototype[method].bind) {\n      ppReactL10nGetContent[method] = Array.prototype[method].bind([pathAsString]);\n    }\n  });\n  return ppReactL10nGetContent;\n}\n/**\n * Transforms a content string into a react compatible array\n * of with strings and react components.\n *\n * @param contentString i.e. 'I want to go see a {movie} at the theatre!'\n * @param options i.e. { data: { movie: <Movie/> } }\n * @return ['I want to go to see a ', <Movie/>, ' at the theatre!']\n */\n\n\nfunction getReactContent(contentString, options) {\n  if (status.logWarnings && typeof options.useHTML !== 'boolean' && process.env.NODE_ENV !== 'production' && Boolean(true) && // using require here to avoid it getting bundled\n  // even though it should get tree-shaken anyway...\n  // it didn't appear to get tree-shaken so... 🙃\n  require('is-html')(contentString)) {\n    log.warn(\"The content at the path \\\"\".concat(String(options.path), \"\\\" appears to have HTML.\"), 'If it is, set the option `useHTML` to `true`.', 'If it is not, then you can silence this warning by explicitly setting `useHTML` to `false`', {\n      contentString: contentString,\n      content: options.content\n    });\n  }\n\n  var interpolatedContent = contentString.split(/({.*?})/).map(function (chunk, index) {\n    if (index % 2 === 1) {\n      var _ref = chunk.match(/^{(.*)}$/)\n      /* istanbul ignore next: paranoid check */\n      || [],\n          _ref2 = _slicedToArray(_ref, 2),\n          key = _ref2[1];\n\n      var val = oget(options.data, key);\n\n      if (options.useHTML && /*#__PURE__*/React.isValidElement(val)) {\n        throw new Error('[pp-react-l10n]: cannot pass react elements as data when useHTML is true.');\n      }\n\n      var escaped = options.useHTML ? lodash_escape(val) : val;\n      return keyifyReactElements(escaped);\n    }\n\n    return chunk;\n  });\n  var shouldJoinContent = interpolatedContent.every(function (chunk) {\n    return typeof chunk === 'string' || typeof chunk === 'number' || !chunk;\n  });\n  var joinedContent = shouldJoinContent ? interpolatedContent.join('') : interpolatedContent;\n\n  if (options.useHTML && typeof joinedContent === 'string') {\n    return innerHTML(joinedContent);\n  }\n\n  return joinedContent;\n}\n/**\n * This function is intended to take React components that are used in translations and add a `key` to them if needed\n * This is to prevent React from logging an error because in normal cases you would need a `key` for React to keep track\n * of the components in the array. We don't need this optimization for our l10n stuff, so we don't really need the\n * `key` in these components.\n *\n * This function dynamically adds a key to the component by making a clone of the component and adding a unique key to\n * it. This adds overhead. React doesn't log the warning when process.env.NODE_ENV === 'production'. So we likewise will\n * skip cloning the component in the same scenario. This should remove any issues regarding performance.\n *\n * @param {*} component the component to check (can be a String as well, which will be skipped)\n * @return {*} the cloned component/same thing you called this with depending on what was passed\n */\n\n\nfunction keyifyReactElements(component) {\n  if (process.env.NODE_ENV !== 'production' && component && typeof component !== 'string' && component.key === null) {\n    return /*#__PURE__*/React.cloneElement(component, {\n      key: Math.random()\n    });\n  }\n\n  return component;\n}\n\nfunction innerHTML(__html) {\n  return /*#__PURE__*/React.createElement('span', {\n    key: __html,\n    dangerouslySetInnerHTML: {\n      __html: __html\n    }\n  });\n}\n\nvar internalGetContent;\n\nfunction getContentFacade() {\n  if (!status.complete) {\n    if (status.logWarnings) {\n      throw new Error(\"[pp-react-l10n]: must be initialized before an attempt is made at getting content. If you're loading content asynchronously, you can disable this by calling the postponeWarnings function. In this case, make certain to rerender your application after you've initialized pp-react-l10n to avoid issues with components not displaying content.\");\n    }\n\n    return getContent(_objectSpread({\n      path: arguments.length <= 0 ? undefined : arguments[0],\n      content: {},\n      onContentMissing: logContentMissing\n    }, arguments.length <= 1 ? undefined : arguments[1]));\n  } // $FlowIgnore flow isn't smart enough to know that this is a GetContentFn\n\n\n  return internalGetContent.apply(void 0, arguments);\n}\n\nfunction init() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; // I'd prefer to destructure options in the parameter list, but flow had a hard time with that... No idea why\n\n  var content = options.content,\n      _options$contentNode = options.contentNode,\n      contentNode = _options$contentNode === void 0 ? content ? null : document.getElementById('l10n-content') : _options$contentNode,\n      _options$onContentMis = options.onContentMissing,\n      onContentMissing = _options$onContentMis === void 0 ? logContentMissing : _options$onContentMis;\n\n  if (content && contentNode) {\n    log.error('INIT:error', 'You passed `content` and `contentNode`. You should only pass one. Using `content`.');\n  }\n\n  content = content ? content : getContentFromNode(contentNode); // $FlowIgnore flow isn't smart enough to know that by not passing path, it'll return a GetContentFn\n\n  internalGetContent = getContent({\n    content: content,\n    onContentMissing: onContentMissing\n  });\n  setComplete();\n  Object.assign(globalContent, content);\n}\n\nfunction getContentFromNode(node) {\n  var content = {};\n\n  if (!node || !node.innerHTML) {\n    if (!node) {\n      log.error('INIT:error', 'The `contentNode` does not exist.', \"If you're using the default, make sure that the #l10n-content node is on the page\", \"If you're doing something custom, make sure the node you're passing exists before calling this.\");\n    } else {\n      log.error('INIT:error The `contentNode` you provided has no content:', node);\n    }\n  } else {\n    try {\n      content = JSON.parse(node.innerHTML);\n      log.info('INIT:parsed:content', content);\n    } catch (e) {\n      log.info('INIT:parsed:content:error', e); // ignore error. Maybe we should rethrow it?\n    }\n  }\n\n  return content;\n}\n\nfunction logContentMissing(_ref) {\n  var path = _ref.path,\n      content = _ref.content;\n\n  if (status.logWarnings) {\n    log.warn(\"missing content for path \\\"\".concat(String(path), \"\\\" with the content:\"), content);\n  }\n}\n\nvar version = String(\"2.1.0\");\nexport default getContentFacade;\nexport { init, logContentMissing, getContent, version, postponeWarnings };","// This currentContext variable will only be used if the makeSlotClass\n// function is called, which happens only if this is the first copy of the\n// @wry/context package to be imported.\nvar currentContext = null; // This unique internal object is used to denote the absence of a value\n// for a given Slot, and is never exposed to outside code.\n\nvar MISSING_VALUE = {};\nvar idCounter = 1; // Although we can't do anything about the cost of duplicated code from\n// accidentally bundling multiple copies of the @wry/context package, we can\n// avoid creating the Slot class more than once using makeSlotClass.\n\nvar makeSlotClass = function makeSlotClass() {\n  return (\n    /** @class */\n    function () {\n      function Slot() {\n        // If you have a Slot object, you can find out its slot.id, but you cannot\n        // guess the slot.id of a Slot you don't have access to, thanks to the\n        // randomized suffix.\n        this.id = [\"slot\", idCounter++, Date.now(), Math.random().toString(36).slice(2)].join(\":\");\n      }\n\n      Slot.prototype.hasValue = function () {\n        for (var context_1 = currentContext; context_1; context_1 = context_1.parent) {\n          // We use the Slot object iself as a key to its value, which means the\n          // value cannot be obtained without a reference to the Slot object.\n          if (this.id in context_1.slots) {\n            var value = context_1.slots[this.id];\n            if (value === MISSING_VALUE) break;\n\n            if (context_1 !== currentContext) {\n              // Cache the value in currentContext.slots so the next lookup will\n              // be faster. This caching is safe because the tree of contexts and\n              // the values of the slots are logically immutable.\n              currentContext.slots[this.id] = value;\n            }\n\n            return true;\n          }\n        }\n\n        if (currentContext) {\n          // If a value was not found for this Slot, it's never going to be found\n          // no matter how many times we look it up, so we might as well cache\n          // the absence of the value, too.\n          currentContext.slots[this.id] = MISSING_VALUE;\n        }\n\n        return false;\n      };\n\n      Slot.prototype.getValue = function () {\n        if (this.hasValue()) {\n          return currentContext.slots[this.id];\n        }\n      };\n\n      Slot.prototype.withValue = function (value, callback, // Given the prevalence of arrow functions, specifying arguments is likely\n      // to be much more common than specifying `this`, hence this ordering:\n      args, thisArg) {\n        var _a;\n\n        var slots = (_a = {\n          __proto__: null\n        }, _a[this.id] = value, _a);\n        var parent = currentContext;\n        currentContext = {\n          parent: parent,\n          slots: slots\n        };\n\n        try {\n          // Function.prototype.apply allows the arguments array argument to be\n          // omitted or undefined, so args! is fine here.\n          return callback.apply(thisArg, args);\n        } finally {\n          currentContext = parent;\n        }\n      }; // Capture the current context and wrap a callback function so that it\n      // reestablishes the captured context when called.\n\n\n      Slot.bind = function (callback) {\n        var context = currentContext;\n        return function () {\n          var saved = currentContext;\n\n          try {\n            currentContext = context;\n            return callback.apply(this, arguments);\n          } finally {\n            currentContext = saved;\n          }\n        };\n      }; // Immediately run a callback function without any captured context.\n\n\n      Slot.noContext = function (callback, // Given the prevalence of arrow functions, specifying arguments is likely\n      // to be much more common than specifying `this`, hence this ordering:\n      args, thisArg) {\n        if (currentContext) {\n          var saved = currentContext;\n\n          try {\n            currentContext = null; // Function.prototype.apply allows the arguments array argument to be\n            // omitted or undefined, so args! is fine here.\n\n            return callback.apply(thisArg, args);\n          } finally {\n            currentContext = saved;\n          }\n        } else {\n          return callback.apply(thisArg, args);\n        }\n      };\n\n      return Slot;\n    }()\n  );\n}; // We store a single global implementation of the Slot class as a permanent\n// non-enumerable symbol property of the Array constructor. This obfuscation\n// does nothing to prevent access to the Slot class, but at least it ensures\n// the implementation (i.e. currentContext) cannot be tampered with, and all\n// copies of the @wry/context package (hopefully just one) will share the\n// same Slot implementation. Since the first copy of the @wry/context package\n// to be imported wins, this technique imposes a very high cost for any\n// future breaking changes to the Slot class.\n\n\nvar globalKey = \"@wry/context:Slot\";\nvar host = Array;\n\nvar Slot = host[globalKey] || function () {\n  var Slot = makeSlotClass();\n\n  try {\n    Object.defineProperty(host, globalKey, {\n      value: host[globalKey] = Slot,\n      enumerable: false,\n      writable: false,\n      configurable: false\n    });\n  } finally {\n    return Slot;\n  }\n}();\n\nvar bind = Slot.bind,\n    noContext = Slot.noContext;\n\nfunction setTimeoutWithContext(callback, delay) {\n  return setTimeout(bind(callback), delay);\n} // Turn any generator function into an async function (using yield instead\n// of await), with context automatically preserved across yields.\n\n\nfunction asyncFromGen(genFn) {\n  return function () {\n    var gen = genFn.apply(this, arguments);\n    var boundNext = bind(gen.next);\n    var boundThrow = bind(gen.throw);\n    return new Promise(function (resolve, reject) {\n      function invoke(method, argument) {\n        try {\n          var result = method.call(gen, argument);\n        } catch (error) {\n          return reject(error);\n        }\n\n        var next = result.done ? resolve : invokeNext;\n\n        if (isPromiseLike(result.value)) {\n          result.value.then(next, result.done ? reject : invokeThrow);\n        } else {\n          next(result.value);\n        }\n      }\n\n      var invokeNext = function invokeNext(value) {\n        return invoke(boundNext, value);\n      };\n\n      var invokeThrow = function invokeThrow(error) {\n        return invoke(boundThrow, error);\n      };\n\n      invokeNext();\n    });\n  };\n}\n\nfunction isPromiseLike(value) {\n  return value && typeof value.then === \"function\";\n} // If you use the fibers npm package to implement coroutines in Node.js,\n// you should call this function at least once to ensure context management\n// remains coherent across any yields.\n\n\nvar wrappedFibers = [];\n\nfunction wrapYieldingFiberMethods(Fiber) {\n  // There can be only one implementation of Fiber per process, so this array\n  // should never grow longer than one element.\n  if (wrappedFibers.indexOf(Fiber) < 0) {\n    var wrap = function wrap(obj, method) {\n      var fn = obj[method];\n\n      obj[method] = function () {\n        return noContext(fn, arguments, this);\n      };\n    }; // These methods can yield, according to\n    // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\n\n\n    wrap(Fiber, \"yield\");\n    wrap(Fiber.prototype, \"run\");\n    wrap(Fiber.prototype, \"throwInto\");\n    wrappedFibers.push(Fiber);\n  }\n\n  return Fiber;\n}\n\nexport { Slot, asyncFromGen, bind, noContext, setTimeoutWithContext as setTimeout, wrapYieldingFiberMethods };","import { Slot } from '@wry/context';\nexport { asyncFromGen, bind as bindContext, noContext, setTimeout } from '@wry/context';\n\nfunction defaultDispose() {}\n\nvar Cache =\n/** @class */\nfunction () {\n  function Cache(max, dispose) {\n    if (max === void 0) {\n      max = Infinity;\n    }\n\n    if (dispose === void 0) {\n      dispose = defaultDispose;\n    }\n\n    this.max = max;\n    this.dispose = dispose;\n    this.map = new Map();\n    this.newest = null;\n    this.oldest = null;\n  }\n\n  Cache.prototype.has = function (key) {\n    return this.map.has(key);\n  };\n\n  Cache.prototype.get = function (key) {\n    var entry = this.getEntry(key);\n    return entry && entry.value;\n  };\n\n  Cache.prototype.getEntry = function (key) {\n    var entry = this.map.get(key);\n\n    if (entry && entry !== this.newest) {\n      var older = entry.older,\n          newer = entry.newer;\n\n      if (newer) {\n        newer.older = older;\n      }\n\n      if (older) {\n        older.newer = newer;\n      }\n\n      entry.older = this.newest;\n      entry.older.newer = entry;\n      entry.newer = null;\n      this.newest = entry;\n\n      if (entry === this.oldest) {\n        this.oldest = newer;\n      }\n    }\n\n    return entry;\n  };\n\n  Cache.prototype.set = function (key, value) {\n    var entry = this.getEntry(key);\n\n    if (entry) {\n      return entry.value = value;\n    }\n\n    entry = {\n      key: key,\n      value: value,\n      newer: null,\n      older: this.newest\n    };\n\n    if (this.newest) {\n      this.newest.newer = entry;\n    }\n\n    this.newest = entry;\n    this.oldest = this.oldest || entry;\n    this.map.set(key, entry);\n    return entry.value;\n  };\n\n  Cache.prototype.clean = function () {\n    while (this.oldest && this.map.size > this.max) {\n      this.delete(this.oldest.key);\n    }\n  };\n\n  Cache.prototype.delete = function (key) {\n    var entry = this.map.get(key);\n\n    if (entry) {\n      if (entry === this.newest) {\n        this.newest = entry.older;\n      }\n\n      if (entry === this.oldest) {\n        this.oldest = entry.newer;\n      }\n\n      if (entry.newer) {\n        entry.newer.older = entry.older;\n      }\n\n      if (entry.older) {\n        entry.older.newer = entry.newer;\n      }\n\n      this.map.delete(key);\n      this.dispose(entry.value, key);\n      return true;\n    }\n\n    return false;\n  };\n\n  return Cache;\n}();\n\nvar parentEntrySlot = new Slot();\nvar reusableEmptyArray = [];\nvar emptySetPool = [];\nvar POOL_TARGET_SIZE = 100; // Since this package might be used browsers, we should avoid using the\n// Node built-in assert module.\n\nfunction assert(condition, optionalMessage) {\n  if (!condition) {\n    throw new Error(optionalMessage || \"assertion failure\");\n  }\n}\n\nfunction valueIs(a, b) {\n  var len = a.length;\n  return (// Unknown values are not equal to each other.\n    len > 0 && // Both values must be ordinary (or both exceptional) to be equal.\n    len === b.length && // The underlying value or exception must be the same.\n    a[len - 1] === b[len - 1]\n  );\n}\n\nfunction valueGet(value) {\n  switch (value.length) {\n    case 0:\n      throw new Error(\"unknown value\");\n\n    case 1:\n      return value[0];\n\n    case 2:\n      throw value[1];\n  }\n}\n\nfunction valueCopy(value) {\n  return value.slice(0);\n}\n\nvar Entry =\n/** @class */\nfunction () {\n  function Entry(fn, args) {\n    this.fn = fn;\n    this.args = args;\n    this.parents = new Set();\n    this.childValues = new Map(); // When this Entry has children that are dirty, this property becomes\n    // a Set containing other Entry objects, borrowed from emptySetPool.\n    // When the set becomes empty, it gets recycled back to emptySetPool.\n\n    this.dirtyChildren = null;\n    this.dirty = true;\n    this.recomputing = false;\n    this.value = [];\n    ++Entry.count;\n  } // This is the most important method of the Entry API, because it\n  // determines whether the cached this.value can be returned immediately,\n  // or must be recomputed. The overall performance of the caching system\n  // depends on the truth of the following observations: (1) this.dirty is\n  // usually false, (2) this.dirtyChildren is usually null/empty, and thus\n  // (3) valueGet(this.value) is usually returned without recomputation.\n\n\n  Entry.prototype.recompute = function () {\n    assert(!this.recomputing, \"already recomputing\");\n\n    if (!rememberParent(this) && maybeReportOrphan(this)) {\n      // The recipient of the entry.reportOrphan callback decided to dispose\n      // of this orphan entry by calling entry.dispose(), so we don't need to\n      // (and should not) proceed with the recomputation.\n      return void 0;\n    }\n\n    return mightBeDirty(this) ? reallyRecompute(this) : valueGet(this.value);\n  };\n\n  Entry.prototype.setDirty = function () {\n    if (this.dirty) return;\n    this.dirty = true;\n    this.value.length = 0;\n    reportDirty(this); // We can go ahead and unsubscribe here, since any further dirty\n    // notifications we receive will be redundant, and unsubscribing may\n    // free up some resources, e.g. file watchers.\n\n    maybeUnsubscribe(this);\n  };\n\n  Entry.prototype.dispose = function () {\n    var _this = this;\n\n    forgetChildren(this).forEach(maybeReportOrphan);\n    maybeUnsubscribe(this); // Because this entry has been kicked out of the cache (in index.js),\n    // we've lost the ability to find out if/when this entry becomes dirty,\n    // whether that happens through a subscription, because of a direct call\n    // to entry.setDirty(), or because one of its children becomes dirty.\n    // Because of this loss of future information, we have to assume the\n    // worst (that this entry might have become dirty very soon), so we must\n    // immediately mark this entry's parents as dirty. Normally we could\n    // just call entry.setDirty() rather than calling parent.setDirty() for\n    // each parent, but that would leave this entry in parent.childValues\n    // and parent.dirtyChildren, which would prevent the child from being\n    // truly forgotten.\n\n    this.parents.forEach(function (parent) {\n      parent.setDirty();\n      forgetChild(parent, _this);\n    });\n  };\n\n  Entry.count = 0;\n  return Entry;\n}();\n\nfunction rememberParent(child) {\n  var parent = parentEntrySlot.getValue();\n\n  if (parent) {\n    child.parents.add(parent);\n\n    if (!parent.childValues.has(child)) {\n      parent.childValues.set(child, []);\n    }\n\n    if (mightBeDirty(child)) {\n      reportDirtyChild(parent, child);\n    } else {\n      reportCleanChild(parent, child);\n    }\n\n    return parent;\n  }\n}\n\nfunction reallyRecompute(entry) {\n  // Since this recomputation is likely to re-remember some of this\n  // entry's children, we forget our children here but do not call\n  // maybeReportOrphan until after the recomputation finishes.\n  var originalChildren = forgetChildren(entry); // Set entry as the parent entry while calling recomputeNewValue(entry).\n\n  parentEntrySlot.withValue(entry, recomputeNewValue, [entry]);\n\n  if (maybeSubscribe(entry)) {\n    // If we successfully recomputed entry.value and did not fail to\n    // (re)subscribe, then this Entry is no longer explicitly dirty.\n    setClean(entry);\n  } // Now that we've had a chance to re-remember any children that were\n  // involved in the recomputation, we can safely report any orphan\n  // children that remain.\n\n\n  originalChildren.forEach(maybeReportOrphan);\n  return valueGet(entry.value);\n}\n\nfunction recomputeNewValue(entry) {\n  entry.recomputing = true; // Set entry.value as unknown.\n\n  entry.value.length = 0;\n\n  try {\n    // If entry.fn succeeds, entry.value will become a normal Value.\n    entry.value[0] = entry.fn.apply(null, entry.args);\n  } catch (e) {\n    // If entry.fn throws, entry.value will become exceptional.\n    entry.value[1] = e;\n  } // Either way, this line is always reached.\n\n\n  entry.recomputing = false;\n}\n\nfunction mightBeDirty(entry) {\n  return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\n}\n\nfunction setClean(entry) {\n  entry.dirty = false;\n\n  if (mightBeDirty(entry)) {\n    // This Entry may still have dirty children, in which case we can't\n    // let our parents know we're clean just yet.\n    return;\n  }\n\n  reportClean(entry);\n}\n\nfunction reportDirty(child) {\n  child.parents.forEach(function (parent) {\n    return reportDirtyChild(parent, child);\n  });\n}\n\nfunction reportClean(child) {\n  child.parents.forEach(function (parent) {\n    return reportCleanChild(parent, child);\n  });\n} // Let a parent Entry know that one of its children may be dirty.\n\n\nfunction reportDirtyChild(parent, child) {\n  // Must have called rememberParent(child) before calling\n  // reportDirtyChild(parent, child).\n  assert(parent.childValues.has(child));\n  assert(mightBeDirty(child));\n\n  if (!parent.dirtyChildren) {\n    parent.dirtyChildren = emptySetPool.pop() || new Set();\n  } else if (parent.dirtyChildren.has(child)) {\n    // If we already know this child is dirty, then we must have already\n    // informed our own parents that we are dirty, so we can terminate\n    // the recursion early.\n    return;\n  }\n\n  parent.dirtyChildren.add(child);\n  reportDirty(parent);\n} // Let a parent Entry know that one of its children is no longer dirty.\n\n\nfunction reportCleanChild(parent, child) {\n  // Must have called rememberChild(child) before calling\n  // reportCleanChild(parent, child).\n  assert(parent.childValues.has(child));\n  assert(!mightBeDirty(child));\n  var childValue = parent.childValues.get(child);\n\n  if (childValue.length === 0) {\n    parent.childValues.set(child, valueCopy(child.value));\n  } else if (!valueIs(childValue, child.value)) {\n    parent.setDirty();\n  }\n\n  removeDirtyChild(parent, child);\n\n  if (mightBeDirty(parent)) {\n    return;\n  }\n\n  reportClean(parent);\n}\n\nfunction removeDirtyChild(parent, child) {\n  var dc = parent.dirtyChildren;\n\n  if (dc) {\n    dc.delete(child);\n\n    if (dc.size === 0) {\n      if (emptySetPool.length < POOL_TARGET_SIZE) {\n        emptySetPool.push(dc);\n      }\n\n      parent.dirtyChildren = null;\n    }\n  }\n} // If the given entry has a reportOrphan method, and no remaining parents,\n// call entry.reportOrphan and return true iff it returns true. The\n// reportOrphan function should return true to indicate entry.dispose()\n// has been called, and the entry has been removed from any other caches\n// (see index.js for the only current example).\n\n\nfunction maybeReportOrphan(entry) {\n  return entry.parents.size === 0 && typeof entry.reportOrphan === \"function\" && entry.reportOrphan() === true;\n} // Removes all children from this entry and returns an array of the\n// removed children.\n\n\nfunction forgetChildren(parent) {\n  var children = reusableEmptyArray;\n\n  if (parent.childValues.size > 0) {\n    children = [];\n    parent.childValues.forEach(function (_value, child) {\n      forgetChild(parent, child);\n      children.push(child);\n    });\n  } // After we forget all our children, this.dirtyChildren must be empty\n  // and therefore must have been reset to null.\n\n\n  assert(parent.dirtyChildren === null);\n  return children;\n}\n\nfunction forgetChild(parent, child) {\n  child.parents.delete(parent);\n  parent.childValues.delete(child);\n  removeDirtyChild(parent, child);\n}\n\nfunction maybeSubscribe(entry) {\n  if (typeof entry.subscribe === \"function\") {\n    try {\n      maybeUnsubscribe(entry); // Prevent double subscriptions.\n\n      entry.unsubscribe = entry.subscribe.apply(null, entry.args);\n    } catch (e) {\n      // If this Entry has a subscribe function and it threw an exception\n      // (or an unsubscribe function it previously returned now throws),\n      // return false to indicate that we were not able to subscribe (or\n      // unsubscribe), and this Entry should remain dirty.\n      entry.setDirty();\n      return false;\n    }\n  } // Returning true indicates either that there was no entry.subscribe\n  // function or that it succeeded.\n\n\n  return true;\n}\n\nfunction maybeUnsubscribe(entry) {\n  var unsubscribe = entry.unsubscribe;\n\n  if (typeof unsubscribe === \"function\") {\n    entry.unsubscribe = void 0;\n    unsubscribe();\n  }\n} // A trie data structure that holds object keys weakly, yet can also hold\n// non-object keys, unlike the native `WeakMap`.\n\n\nvar KeyTrie =\n/** @class */\nfunction () {\n  function KeyTrie(weakness) {\n    this.weakness = weakness;\n  }\n\n  KeyTrie.prototype.lookup = function () {\n    var array = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      array[_i] = arguments[_i];\n    }\n\n    return this.lookupArray(array);\n  };\n\n  KeyTrie.prototype.lookupArray = function (array) {\n    var node = this;\n    array.forEach(function (key) {\n      return node = node.getChildTrie(key);\n    });\n    return node.data || (node.data = Object.create(null));\n  };\n\n  KeyTrie.prototype.getChildTrie = function (key) {\n    var map = this.weakness && isObjRef(key) ? this.weak || (this.weak = new WeakMap()) : this.strong || (this.strong = new Map());\n    var child = map.get(key);\n    if (!child) map.set(key, child = new KeyTrie(this.weakness));\n    return child;\n  };\n\n  return KeyTrie;\n}();\n\nfunction isObjRef(value) {\n  switch (typeof value) {\n    case \"object\":\n      if (value === null) break;\n    // Fall through to return true...\n\n    case \"function\":\n      return true;\n  }\n\n  return false;\n} // The defaultMakeCacheKey function is remarkably powerful, because it gives\n// a unique object for any shallow-identical list of arguments. If you need\n// to implement a custom makeCacheKey function, you may find it helpful to\n// delegate the final work to defaultMakeCacheKey, which is why we export it\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\n// does not support WeakMap, or you have the ability to return a string key.\n// In those cases, just write your own custom makeCacheKey functions.\n\n\nvar keyTrie = new KeyTrie(typeof WeakMap === \"function\");\n\nfunction defaultMakeCacheKey() {\n  var args = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    args[_i] = arguments[_i];\n  }\n\n  return keyTrie.lookupArray(args);\n}\n\nvar caches = new Set();\n\nfunction wrap(originalFunction, options) {\n  if (options === void 0) {\n    options = Object.create(null);\n  }\n\n  var cache = new Cache(options.max || Math.pow(2, 16), function (entry) {\n    return entry.dispose();\n  });\n  var disposable = !!options.disposable;\n  var makeCacheKey = options.makeCacheKey || defaultMakeCacheKey;\n\n  function optimistic() {\n    if (disposable && !parentEntrySlot.hasValue()) {\n      // If there's no current parent computation, and this wrapped\n      // function is disposable (meaning we don't care about entry.value,\n      // just dependency tracking), then we can short-cut everything else\n      // in this function, because entry.recompute() is going to recycle\n      // the entry object without recomputing anything, anyway.\n      return void 0;\n    }\n\n    var key = makeCacheKey.apply(null, arguments);\n\n    if (key === void 0) {\n      return originalFunction.apply(null, arguments);\n    }\n\n    var args = Array.prototype.slice.call(arguments);\n    var entry = cache.get(key);\n\n    if (entry) {\n      entry.args = args;\n    } else {\n      entry = new Entry(originalFunction, args);\n      cache.set(key, entry);\n      entry.subscribe = options.subscribe;\n\n      if (disposable) {\n        entry.reportOrphan = function () {\n          return cache.delete(key);\n        };\n      }\n    }\n\n    var value = entry.recompute(); // Move this entry to the front of the least-recently used queue,\n    // since we just finished computing its value.\n\n    cache.set(key, entry);\n    caches.add(cache); // Clean up any excess entries in the cache, but only if there is no\n    // active parent entry, meaning we're not in the middle of a larger\n    // computation that might be flummoxed by the cleaning.\n\n    if (!parentEntrySlot.hasValue()) {\n      caches.forEach(function (cache) {\n        return cache.clean();\n      });\n      caches.clear();\n    } // If options.disposable is truthy, the caller of wrap is telling us\n    // they don't care about the result of entry.recompute(), so we should\n    // avoid returning the value, so it won't be accidentally used.\n\n\n    return disposable ? void 0 : value;\n  }\n\n  optimistic.dirty = function () {\n    var key = makeCacheKey.apply(null, arguments);\n    var child = key !== void 0 && cache.get(key);\n\n    if (child) {\n      child.setDirty();\n    }\n  };\n\n  return optimistic;\n}\n\nexport { KeyTrie, defaultMakeCacheKey, wrap };"],"sourceRoot":""}