msw 0.21.3 → 0.22.3

package/lib/umd/index.js

@@ -4,7 +4,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MockServiceWorker = {}));
 }(this, (function (exports) { 'use strict';
 
-  var codes = {
+  var statuses = {
   	"100": "Continue",
   	"101": "Switching Protocols",
   	"102": "Processing",
@@ -70,11 +70,6 @@
   	"511": "Network Authentication Required"
   };
 
-  var statuses = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    'default': codes
-  });
-
   const status = (statusCode, statusText) => {
       return (res) => {
           res.status = statusCode;
@@ -584,16 +579,54 @@
   };
 
   /**
-   * Returns a GraphQL body payload.
+   * Determines if the given value is an object.
    */
-  const data = (payload) => {
+  function isObject(value) {
+      return value != null && typeof value === 'object' && !Array.isArray(value);
+  }
+
+  /**
+   * Deeply merges two given objects with the right one
+   * having a priority during property assignment.
+   */
+  function mergeRight(left, right) {
+      return Object.entries(right).reduce((result, [key, rightValue]) => {
+          const leftValue = result[key];
+          if (Array.isArray(leftValue) && Array.isArray(rightValue)) {
+              result[key] = leftValue.concat(rightValue);
+              return result;
+          }
+          if (isObject(leftValue) && isObject(rightValue)) {
+              result[key] = mergeRight(leftValue, rightValue);
+              return result;
+          }
+          result[key] = rightValue;
+          return result;
+      }, Object.assign({}, left));
+  }
+
+  /**
+   * Sets the given value as the JSON body of the response.
+   * @example
+   * res(json({ key: 'value' }))
+   * res(json('Some string'))
+   * res(json([1, '2', false, { ok: true }]))
+   */
+  const json = (body, { merge = false } = {}) => {
       return (res) => {
           res.headers.set('Content-Type', 'application/json');
-          res.body = JSON.stringify({ data: payload });
+          res.body = merge ? mergeRight(res.body || {}, body) : body;
           return res;
       };
   };
 
+  /**
+   * Returns a GraphQL body payload.
+   */
+  const data = (payload) => {
+      return json({ data: payload }, { merge: true });
+  };
+
   /**
    * Returns a boolean indicating if the current process is running in NodeJS environment.
    * @see https://github.com/mswjs/msw/pull/255
@@ -634,25 +667,13 @@
   };
 
   /**
-   * Sets the given value as the JSON body of the response.
-   * @example
-   * res(json({ key: 'value' }))
-   * res(json('Some string'))
-   * res(json([1, '2', false, { ok: true }]))
-   */
-  const json = (body) => {
-      return (res) => {
-          res.headers.set('Content-Type', 'application/json');
-          res.body = JSON.stringify(body);
-          return res;
-      };
-  };
-
-  /**
-   * Returns a list of GraphQL errors.
+   * Sets a given list of GraphQL errors on the mocked response.
    */
   const errors = (errorsList) => {
-      return json({ errors: errorsList });
+      if (errorsList == null) {
+          return (res) => res;
+      }
+      return json({ errors: errorsList }, { merge: true });
   };
 
   const useFetch = isNodeProcess() ? require('node-fetch') : window.fetch;
@@ -728,18 +749,18 @@
   });
 
   /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
+  Copyright (c) Microsoft Corporation. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
 
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
 
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
   ***************************************************************************** */
 
   function __awaiter(thisArg, _arguments, P, generator) {
@@ -920,6 +941,17 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
       }
   }
 
+  /**
+   * Internal response transformer to ensure response JSON body
+   * is always stringified.
+   */
+  const stringifyJsonBody = (res) => {
+      var _a, _b;
+      if (res.body && ((_b = (_a = res.headers) === null || _a === void 0 ? void 0 : _a.get('content-type')) === null || _b === void 0 ? void 0 : _b.endsWith('json'))) {
+          res.body = JSON.stringify(res.body);
+      }
+      return res;
+  };
   const defaultResponse = {
       status: 200,
       statusText: 'OK',
@@ -927,16 +959,23 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
       delay: 0,
       once: false,
   };
-  function createResponseComposition(overrides = {}) {
+  const defaultResponseTransformers = [
+      stringifyJsonBody,
+  ];
+  function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
       return (...transformers) => {
-          const resolvedResponse = Object.assign({}, defaultResponse, {
+          const initialResponse = Object.assign({}, defaultResponse, {
               headers: new lib.Headers({
                   'x-powered-by': 'msw',
               }),
-          }, overrides);
-          if (transformers.length > 0) {
-              return compose(...transformers)(resolvedResponse);
-          }
+          }, responseOverrides);
+          const resolvedTransformers = [
+              ...defaultTransformers,
+              ...transformers,
+          ].filter(Boolean);
+          const resolvedResponse = resolvedTransformers.length > 0
+              ? compose(...resolvedTransformers)(initialResponse)
+              : initialResponse;
           return resolvedResponse;
       };
   }
@@ -2378,9 +2417,9 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
           });
   };
 
-  function onUnhandledRequest(request, onUnhandledRequest = 'bypass') {
-      if (typeof onUnhandledRequest === 'function') {
-          onUnhandledRequest(request);
+  function onUnhandledRequest(request, handler = 'bypass') {
+      if (typeof handler === 'function') {
+          handler(request);
           return;
       }
       const publicUrl = getPublicUrlFromRequest(request);
@@ -2391,7 +2430,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
   rest.${request.method.toLowerCase()}('${publicUrl}', (req, res, ctx) => {
     return res(ctx.text('body'))
   })`;
-      switch (onUnhandledRequest) {
+      switch (handler) {
           case 'error': {
               throw new Error(`[MSW] Error: ${message}`);
           }
@@ -2558,8 +2597,8 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
           const { payload: actualChecksum } = yield context.events.once('INTEGRITY_CHECK_RESPONSE');
           // Compare the response from the Service Worker and the
           // global variable set by webpack upon build.
-          if (actualChecksum !== "d1e0e502f550d40a34bee90822e4bf98") {
-              throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"d1e0e502f550d40a34bee90822e4bf98"}).`);
+          if (actualChecksum !== "65d33ca82955e1c5928aed19d1bdf3f9") {
+              throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"65d33ca82955e1c5928aed19d1bdf3f9"}).`);
           }
           return serviceWorker;
       });
@@ -2590,30 +2629,6 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
       });
   }
 
-  function isObject(obj) {
-      return typeof obj === 'object';
-  }
-  /**
-   * Deeply merges two given objects with the right one
-   * having a priority during property assignment.
-   */
-  function mergeRight(a, b) {
-      const result = Object.assign({}, a);
-      Object.entries(b).forEach(([key, value]) => {
-          const existingValue = result[key];
-          if (Array.isArray(existingValue) && Array.isArray(value)) {
-              result[key] = existingValue.concat(value);
-              return;
-          }
-          if (isObject(existingValue) && isObject(value)) {
-              result[key] = mergeRight(existingValue, value);
-              return;
-          }
-          result[key] = value;
-      });
-      return result;
-  }
-
   const DEFAULT_START_OPTIONS = {
       serviceWorker: {
           url: '/mockServiceWorker.js',
@@ -2803,6 +2818,18 @@ If this message still persists after updating, please report an issue: https://g
           resetHandlers(...nextHandlers) {
               context.requestHandlers = resetHandlers(requestHandlers, ...nextHandlers);
           },
+          printHandlers() {
+              context.requestHandlers.forEach((handler) => {
+                  const meta = handler.getMetaInfo();
+                  console.groupCollapsed(meta.header);
+                  console.log(`Declaration: ${meta.callFrame}`);
+                  console.log('Resolver: %s', handler.resolver);
+                  if (['rest'].includes(meta.type)) {
+                      console.log('Match:', `https://mswjs.io/repl?path=${meta.mask}`);
+                  }
+                  console.groupEnd();
+              });
+          },
       };
   }
 
@@ -2859,13 +2886,13 @@ If this message still persists after updating, please report an issue: https://g
           .replace(/\?/g, '\\?')
           // Ignore trailing slashes
           .replace(/\/+$/, '')
-          // Replace wildcard with any single character sequence
-          .replace(/\*+/g, '.+')
+          // Replace wildcard with any zero-to-any character sequence
+          .replace(/\*+/g, '.*')
           // Replace parameters with named capturing groups
-          .replace(/:([^\d|^\/][a-zA-Z0-9]*(?=(?:\/|\\.)|$))/g, (_, match) => `(?<${match}>.+?)`)
+          .replace(/:([^\d|^\/][a-zA-Z0-9_]*(?=(?:\/|\\.)|$))/g, (_, paramName) => `(?<${paramName}>[^\/]+?)`)
           // Allow optional trailing slash
           .concat('(\\/|$)');
-      return new RegExp(pattern, 'g');
+      return new RegExp(pattern, 'gi');
   };
 
   /**
@@ -2886,6 +2913,7 @@ If this message still persists after updating, please report an issue: https://g
 
   var getCleanUrl_1 = createCommonjsModule(function (module, exports) {
   Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getCleanUrl = void 0;
   /**
    * Removes query parameters and hashes from a given URL.
    */
@@ -2894,6 +2922,7 @@ If this message still persists after updating, please report an issue: https://g
       return [isAbsolute && url.origin, url.pathname].filter(Boolean).join('');
   }
   exports.getCleanUrl = getCleanUrl;
+
   });
 
   /**
@@ -2952,6 +2981,31 @@ If this message still persists after updating, please report an issue: https://g
       return match(cleanMask, cleanRequestUrl);
   }
 
+  /**
+   * Return the stack trace frame of a function's invocation.
+   */
+  function getCallFrame() {
+      try {
+          const inspectionError = new Error();
+          inspectionError.name = 'Inspection Error';
+          throw inspectionError;
+      }
+      catch (error) {
+          const frames = error.stack.split('\n');
+          // Get the first frame that doesn't reference the library's internal trace.
+          // Assume that frame is the invocation frame.
+          const declarationFrame = frames.slice(1).find((frame) => {
+              return !/(node_modules)?\/lib\/(umd|esm)\//.test(frame);
+          });
+          if (!declarationFrame) {
+              return;
+          }
+          // Extract file reference from the stack frame.
+          const [, declarationPath] = declarationFrame.match(/\((.+?)\)$/) || [];
+          return declarationPath;
+      }
+  }
+
   (function (RESTMethods) {
       RESTMethods["HEAD"] = "HEAD";
       RESTMethods["GET"] = "GET";
@@ -2975,6 +3029,7 @@ If this message still persists after updating, please report an issue: https://g
   const createRestHandler = (method) => {
       return (mask, resolver) => {
           const resolvedMask = getUrlByMask(mask);
+          const callFrame = getCallFrame();
           return {
               parse(req) {
                   // Match the request during parsing to prevent matching it twice
@@ -3025,6 +3080,14 @@ ${queryParams
                   console.log('Response', loggedResponse);
                   console.groupEnd();
               },
+              getMetaInfo() {
+                  return {
+                      type: 'rest',
+                      header: `[rest] ${method} ${mask.toString()}`,
+                      mask,
+                      callFrame,
+                  };
+              },
           };
       };
   };
@@ -3038,154 +3101,19 @@ ${queryParams
       options: createRestHandler(exports.RESTMethods.OPTIONS),
   };
 
-  // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
-  var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;
-
   function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-  var MAX_ARRAY_LENGTH = 10;
-  var MAX_RECURSIVE_DEPTH = 2;
-  /**
-   * Used to print values in error messages.
-   */
-
-  function inspect(value) {
-    return formatValue(value, []);
-  }
-
-  function formatValue(value, seenValues) {
-    switch (_typeof(value)) {
-      case 'string':
-        return JSON.stringify(value);
-
-      case 'function':
-        return value.name ? "[function ".concat(value.name, "]") : '[function]';
-
-      case 'object':
-        if (value === null) {
-          return 'null';
-        }
-
-        return formatObjectValue(value, seenValues);
-
-      default:
-        return String(value);
-    }
-  }
-
-  function formatObjectValue(value, previouslySeenValues) {
-    if (previouslySeenValues.indexOf(value) !== -1) {
-      return '[Circular]';
-    }
-
-    var seenValues = [].concat(previouslySeenValues, [value]);
-    var customInspectFn = getCustomFn(value);
-
-    if (customInspectFn !== undefined) {
-      // $FlowFixMe(>=0.90.0)
-      var customValue = customInspectFn.call(value); // check for infinite recursion
-
-      if (customValue !== value) {
-        return typeof customValue === 'string' ? customValue : formatValue(customValue, seenValues);
-      }
-    } else if (Array.isArray(value)) {
-      return formatArray(value, seenValues);
-    }
-
-    return formatObject(value, seenValues);
-  }
-
-  function formatObject(object, seenValues) {
-    var keys = Object.keys(object);
-
-    if (keys.length === 0) {
-      return '{}';
-    }
-
-    if (seenValues.length > MAX_RECURSIVE_DEPTH) {
-      return '[' + getObjectTag(object) + ']';
-    }
-
-    var properties = keys.map(function (key) {
-      var value = formatValue(object[key], seenValues);
-      return key + ': ' + value;
-    });
-    return '{ ' + properties.join(', ') + ' }';
-  }
-
-  function formatArray(array, seenValues) {
-    if (array.length === 0) {
-      return '[]';
-    }
-
-    if (seenValues.length > MAX_RECURSIVE_DEPTH) {
-      return '[Array]';
-    }
-
-    var len = Math.min(MAX_ARRAY_LENGTH, array.length);
-    var remaining = array.length - len;
-    var items = [];
-
-    for (var i = 0; i < len; ++i) {
-      items.push(formatValue(array[i], seenValues));
-    }
-
-    if (remaining === 1) {
-      items.push('... 1 more item');
-    } else if (remaining > 1) {
-      items.push("... ".concat(remaining, " more items"));
-    }
-
-    return '[' + items.join(', ') + ']';
-  }
-
-  function getCustomFn(object) {
-    var customInspectFn = object[String(nodejsCustomInspectSymbol)];
-
-    if (typeof customInspectFn === 'function') {
-      return customInspectFn;
-    }
-
-    if (typeof object.inspect === 'function') {
-      return object.inspect;
-    }
-  }
-
-  function getObjectTag(object) {
-    var tag = Object.prototype.toString.call(object).replace(/^\[object /, '').replace(/]$/, '');
-
-    if (tag === 'Object' && typeof object.constructor === 'function') {
-      var name = object.constructor.name;
-
-      if (typeof name === 'string' && name !== '') {
-        return name;
-      }
-    }
-
-    return tag;
-  }
-
-  function devAssert(condition, message) {
-    var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')
-
-    if (!booleanCondition) {
-      throw new Error(message);
-    }
-  }
-
-  function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
 
   /**
    * Return true if `value` is object-like. A value is object-like if it's not
    * `null` and has a `typeof` result of "object".
    */
   function isObjectLike(value) {
-    return _typeof$1(value) == 'object' && value !== null;
+    return _typeof(value) == 'object' && value !== null;
   }
 
   // In ES2015 (or a polyfilled) environment, this will be Symbol.iterator
 
-  var SYMBOL_TO_STRING_TAG = // $FlowFixMe Flow doesn't define `Symbol.toStringTag` yet
-  typeof Symbol === 'function' ? Symbol.toStringTag : '@@toStringTag';
+  var SYMBOL_TO_STRING_TAG = typeof Symbol === 'function' && Symbol.toStringTag != null ? Symbol.toStringTag : '@@toStringTag';
 
   /**
    * Represents a location in a Source.
@@ -3278,7 +3206,7 @@ ${queryParams
     return whitespace(len - str.length) + str;
   }
 
-  function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }
+  function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
 
   function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -3290,7 +3218,7 @@ ${queryParams
 
   function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-  function _possibleConstructorReturn(self, call) { if (call && (_typeof$2(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+  function _possibleConstructorReturn(self, call) { if (call && (_typeof$1(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
   function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
@@ -3509,7 +3437,7 @@ ${queryParams
       value: function toString() {
         return printError(this);
       } // FIXME: workaround to not break chai comparisons, should be remove in v16
-      // $FlowFixMe Flow doesn't support computed properties yet
+      // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
 
     }, {
       key: SYMBOL_TO_STRING_TAG,
@@ -3626,6 +3554,9 @@ ${queryParams
     }
   }
 
+  // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
+  var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;
+
   /**
    * The `defineInspect()` function defines `inspect()` prototype method as alias of `toJSON`
    */
@@ -3750,42 +3681,6 @@ ${queryParams
    * The list of all possible AST node types.
    */
 
-  function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-  function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }
-
-  /**
-   * A representation of source input to GraphQL. The `name` and `locationOffset` parameters are
-   * optional, but they are useful for clients who store GraphQL documents in source files.
-   * For example, if the GraphQL input starts at line 40 in a file named `Foo.graphql`, it might
-   * be useful for `name` to be `"Foo.graphql"` and location to be `{ line: 40, column: 1 }`.
-   * The `line` and `column` properties in `locationOffset` are 1-indexed.
-   */
-  var Source = /*#__PURE__*/function () {
-    function Source(body) {
-      var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'GraphQL request';
-      var locationOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
-        line: 1,
-        column: 1
-      };
-      this.body = body;
-      this.name = name;
-      this.locationOffset = locationOffset;
-      this.locationOffset.line > 0 || devAssert(0, 'line in locationOffset is 1-indexed and must be positive.');
-      this.locationOffset.column > 0 || devAssert(0, 'column in locationOffset is 1-indexed and must be positive.');
-    } // $FlowFixMe Flow doesn't support computed properties yet
-
-
-    _createClass$1(Source, [{
-      key: SYMBOL_TO_STRING_TAG,
-      get: function get() {
-        return 'Source';
-      }
-    }]);
-
-    return Source;
-  }();
-
   /**
    * An exported enum describing the different kinds of tokens that the
    * lexer emits.
@@ -3818,8 +3713,213 @@ ${queryParams
    * The enum type representing the token kinds values.
    */
 
+  function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }
+  var MAX_ARRAY_LENGTH = 10;
+  var MAX_RECURSIVE_DEPTH = 2;
   /**
-   * The set of allowed directive location values.
+   * Used to print values in error messages.
+   */
+
+  function inspect(value) {
+    return formatValue(value, []);
+  }
+
+  function formatValue(value, seenValues) {
+    switch (_typeof$2(value)) {
+      case 'string':
+        return JSON.stringify(value);
+
+      case 'function':
+        return value.name ? "[function ".concat(value.name, "]") : '[function]';
+
+      case 'object':
+        if (value === null) {
+          return 'null';
+        }
+
+        return formatObjectValue(value, seenValues);
+
+      default:
+        return String(value);
+    }
+  }
+
+  function formatObjectValue(value, previouslySeenValues) {
+    if (previouslySeenValues.indexOf(value) !== -1) {
+      return '[Circular]';
+    }
+
+    var seenValues = [].concat(previouslySeenValues, [value]);
+    var customInspectFn = getCustomFn(value);
+
+    if (customInspectFn !== undefined) {
+      var customValue = customInspectFn.call(value); // check for infinite recursion
+
+      if (customValue !== value) {
+        return typeof customValue === 'string' ? customValue : formatValue(customValue, seenValues);
+      }
+    } else if (Array.isArray(value)) {
+      return formatArray(value, seenValues);
+    }
+
+    return formatObject(value, seenValues);
+  }
+
+  function formatObject(object, seenValues) {
+    var keys = Object.keys(object);
+
+    if (keys.length === 0) {
+      return '{}';
+    }
+
+    if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+      return '[' + getObjectTag(object) + ']';
+    }
+
+    var properties = keys.map(function (key) {
+      var value = formatValue(object[key], seenValues);
+      return key + ': ' + value;
+    });
+    return '{ ' + properties.join(', ') + ' }';
+  }
+
+  function formatArray(array, seenValues) {
+    if (array.length === 0) {
+      return '[]';
+    }
+
+    if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+      return '[Array]';
+    }
+
+    var len = Math.min(MAX_ARRAY_LENGTH, array.length);
+    var remaining = array.length - len;
+    var items = [];
+
+    for (var i = 0; i < len; ++i) {
+      items.push(formatValue(array[i], seenValues));
+    }
+
+    if (remaining === 1) {
+      items.push('... 1 more item');
+    } else if (remaining > 1) {
+      items.push("... ".concat(remaining, " more items"));
+    }
+
+    return '[' + items.join(', ') + ']';
+  }
+
+  function getCustomFn(object) {
+    var customInspectFn = object[String(nodejsCustomInspectSymbol)];
+
+    if (typeof customInspectFn === 'function') {
+      return customInspectFn;
+    }
+
+    if (typeof object.inspect === 'function') {
+      return object.inspect;
+    }
+  }
+
+  function getObjectTag(object) {
+    var tag = Object.prototype.toString.call(object).replace(/^\[object /, '').replace(/]$/, '');
+
+    if (tag === 'Object' && typeof object.constructor === 'function') {
+      var name = object.constructor.name;
+
+      if (typeof name === 'string' && name !== '') {
+        return name;
+      }
+    }
+
+    return tag;
+  }
+
+  function devAssert(condition, message) {
+    var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')
+
+    if (!booleanCondition) {
+      throw new Error(message);
+    }
+  }
+
+  /**
+   * A replacement for instanceof which includes an error warning when multi-realm
+   * constructors are detected.
+   */
+  // See: https://expressjs.com/en/advanced/best-practice-performance.html#set-node_env-to-production
+  // See: https://webpack.js.org/guides/production/
+  var instanceOf = process.env.NODE_ENV === 'production' ? // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
+  // eslint-disable-next-line no-shadow
+  function instanceOf(value, constructor) {
+    return value instanceof constructor;
+  } : // eslint-disable-next-line no-shadow
+  function instanceOf(value, constructor) {
+    if (value instanceof constructor) {
+      return true;
+    }
+
+    if (value) {
+      var valueClass = value.constructor;
+      var className = constructor.name;
+
+      if (className && valueClass && valueClass.name === className) {
+        throw new Error("Cannot use ".concat(className, " \"").concat(value, "\" from another module or realm.\n\nEnsure that there is only one instance of \"graphql\" in the node_modules\ndirectory. If different versions of \"graphql\" are the dependencies of other\nrelied on modules, use \"resolutions\" to ensure only one version is installed.\n\nhttps://yarnpkg.com/en/docs/selective-version-resolutions\n\nDuplicate \"graphql\" modules cannot be used at the same time since different\nversions may have different capabilities and behavior. The data from one\nversion used in the function from another could produce confusing and\nspurious results."));
+      }
+    }
+
+    return false;
+  };
+
+  function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }
+
+  /**
+   * A representation of source input to GraphQL. The `name` and `locationOffset` parameters are
+   * optional, but they are useful for clients who store GraphQL documents in source files.
+   * For example, if the GraphQL input starts at line 40 in a file named `Foo.graphql`, it might
+   * be useful for `name` to be `"Foo.graphql"` and location to be `{ line: 40, column: 1 }`.
+   * The `line` and `column` properties in `locationOffset` are 1-indexed.
+   */
+  var Source = /*#__PURE__*/function () {
+    function Source(body) {
+      var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'GraphQL request';
+      var locationOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+        line: 1,
+        column: 1
+      };
+      typeof body === 'string' || devAssert(0, "Body must be a string. Received: ".concat(inspect(body), "."));
+      this.body = body;
+      this.name = name;
+      this.locationOffset = locationOffset;
+      this.locationOffset.line > 0 || devAssert(0, 'line in locationOffset is 1-indexed and must be positive.');
+      this.locationOffset.column > 0 || devAssert(0, 'column in locationOffset is 1-indexed and must be positive.');
+    } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+
+
+    _createClass$1(Source, [{
+      key: SYMBOL_TO_STRING_TAG,
+      get: function get() {
+        return 'Source';
+      }
+    }]);
+
+    return Source;
+  }();
+  /**
+   * Test if the given value is a Source object.
+   *
+   * @internal
+   */
+
+  // eslint-disable-next-line no-redeclare
+  function isSource(source) {
+    return instanceOf(source, Source);
+  }
+
+  /**
+   * The set of allowed directive location values.
    */
   var DirectiveLocation = Object.freeze({
     // Request Definitions
@@ -3860,7 +3960,7 @@ ${queryParams
     // Expand a block string's raw value into independent lines.
     var lines = rawString.split(/\r\n|[\n\r]/g); // Remove common indentation from all lines but first.
 
-    var commonIndent = getBlockStringIndentation(lines);
+    var commonIndent = getBlockStringIndentation(rawString);
 
     if (commonIndent !== 0) {
       for (var i = 1; i < lines.length; i++) {
@@ -3869,56 +3969,78 @@ ${queryParams
     } // Remove leading and trailing blank lines.
 
 
-    while (lines.length > 0 && isBlank(lines[0])) {
-      lines.shift();
+    var startLine = 0;
+
+    while (startLine < lines.length && isBlank(lines[startLine])) {
+      ++startLine;
     }
 
-    while (lines.length > 0 && isBlank(lines[lines.length - 1])) {
-      lines.pop();
+    var endLine = lines.length;
+
+    while (endLine > startLine && isBlank(lines[endLine - 1])) {
+      --endLine;
     } // Return a string of the lines joined with U+000A.
 
 
-    return lines.join('\n');
+    return lines.slice(startLine, endLine).join('\n');
+  }
+
+  function isBlank(str) {
+    for (var i = 0; i < str.length; ++i) {
+      if (str[i] !== ' ' && str[i] !== '\t') {
+        return false;
+      }
+    }
+
+    return true;
   }
   /**
    * @internal
    */
 
-  function getBlockStringIndentation(lines) {
-    var commonIndent = null;
 
-    for (var i = 1; i < lines.length; i++) {
-      var line = lines[i];
-      var indent = leadingWhitespace(line);
+  function getBlockStringIndentation(value) {
+    var _commonIndent;
 
-      if (indent === line.length) {
-        continue; // skip empty lines
-      }
+    var isFirstLine = true;
+    var isEmptyLine = true;
+    var indent = 0;
+    var commonIndent = null;
+
+    for (var i = 0; i < value.length; ++i) {
+      switch (value.charCodeAt(i)) {
+        case 13:
+          //  \r
+          if (value.charCodeAt(i + 1) === 10) {
+            ++i; // skip \r\n as one symbol
+          }
 
-      if (commonIndent === null || indent < commonIndent) {
-        commonIndent = indent;
+        // falls through
 
-        if (commonIndent === 0) {
+        case 10:
+          //  \n
+          isFirstLine = false;
+          isEmptyLine = true;
+          indent = 0;
           break;
-        }
-      }
-    }
 
-    return commonIndent === null ? 0 : commonIndent;
-  }
+        case 9: //   \t
 
-  function leadingWhitespace(str) {
-    var i = 0;
+        case 32:
+          //  <space>
+          ++indent;
+          break;
 
-    while (i < str.length && (str[i] === ' ' || str[i] === '\t')) {
-      i++;
+        default:
+          if (isEmptyLine && !isFirstLine && (commonIndent === null || indent < commonIndent)) {
+            commonIndent = indent;
+          }
+
+          isEmptyLine = false;
+      }
     }
 
-    return i;
-  }
-
-  function isBlank(str) {
-    return leadingWhitespace(str) === str.length;
+    return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0 ? _commonIndent : 0;
   }
 
   /**
@@ -4017,161 +4139,257 @@ ${queryParams
     var source = lexer.source;
     var body = source.body;
     var bodyLength = body.length;
-    var pos = positionAfterWhitespace(body, prev.end, lexer);
-    var line = lexer.line;
-    var col = 1 + pos - lexer.lineStart;
+    var pos = prev.end;
 
-    if (pos >= bodyLength) {
-      return new Token(TokenKind.EOF, bodyLength, bodyLength, line, col, prev);
-    }
+    while (pos < bodyLength) {
+      var code = body.charCodeAt(pos);
+      var _line = lexer.line;
 
-    var code = body.charCodeAt(pos); // SourceCharacter
+      var _col = 1 + pos - lexer.lineStart; // SourceCharacter
 
-    switch (code) {
-      // !
-      case 33:
-        return new Token(TokenKind.BANG, pos, pos + 1, line, col, prev);
-      // #
 
-      case 35:
-        return readComment(source, pos, line, col, prev);
-      // $
+      switch (code) {
+        case 0xfeff: // <BOM>
 
-      case 36:
-        return new Token(TokenKind.DOLLAR, pos, pos + 1, line, col, prev);
-      // &
+        case 9: //   \t
 
-      case 38:
-        return new Token(TokenKind.AMP, pos, pos + 1, line, col, prev);
-      // (
+        case 32: //  <space>
 
-      case 40:
-        return new Token(TokenKind.PAREN_L, pos, pos + 1, line, col, prev);
-      // )
+        case 44:
+          //  ,
+          ++pos;
+          continue;
 
-      case 41:
-        return new Token(TokenKind.PAREN_R, pos, pos + 1, line, col, prev);
-      // .
+        case 10:
+          //  \n
+          ++pos;
+          ++lexer.line;
+          lexer.lineStart = pos;
+          continue;
 
-      case 46:
-        if (body.charCodeAt(pos + 1) === 46 && body.charCodeAt(pos + 2) === 46) {
-          return new Token(TokenKind.SPREAD, pos, pos + 3, line, col, prev);
-        }
+        case 13:
+          //  \r
+          if (body.charCodeAt(pos + 1) === 10) {
+            pos += 2;
+          } else {
+            ++pos;
+          }
 
-        break;
-      // :
-
-      case 58:
-        return new Token(TokenKind.COLON, pos, pos + 1, line, col, prev);
-      // =
-
-      case 61:
-        return new Token(TokenKind.EQUALS, pos, pos + 1, line, col, prev);
-      // @
-
-      case 64:
-        return new Token(TokenKind.AT, pos, pos + 1, line, col, prev);
-      // [
-
-      case 91:
-        return new Token(TokenKind.BRACKET_L, pos, pos + 1, line, col, prev);
-      // ]
-
-      case 93:
-        return new Token(TokenKind.BRACKET_R, pos, pos + 1, line, col, prev);
-      // {
-
-      case 123:
-        return new Token(TokenKind.BRACE_L, pos, pos + 1, line, col, prev);
-      // |
-
-      case 124:
-        return new Token(TokenKind.PIPE, pos, pos + 1, line, col, prev);
-      // }
-
-      case 125:
-        return new Token(TokenKind.BRACE_R, pos, pos + 1, line, col, prev);
-      // A-Z _ a-z
-
-      case 65:
-      case 66:
-      case 67:
-      case 68:
-      case 69:
-      case 70:
-      case 71:
-      case 72:
-      case 73:
-      case 74:
-      case 75:
-      case 76:
-      case 77:
-      case 78:
-      case 79:
-      case 80:
-      case 81:
-      case 82:
-      case 83:
-      case 84:
-      case 85:
-      case 86:
-      case 87:
-      case 88:
-      case 89:
-      case 90:
-      case 95:
-      case 97:
-      case 98:
-      case 99:
-      case 100:
-      case 101:
-      case 102:
-      case 103:
-      case 104:
-      case 105:
-      case 106:
-      case 107:
-      case 108:
-      case 109:
-      case 110:
-      case 111:
-      case 112:
-      case 113:
-      case 114:
-      case 115:
-      case 116:
-      case 117:
-      case 118:
-      case 119:
-      case 120:
-      case 121:
-      case 122:
-        return readName(source, pos, line, col, prev);
-      // - 0-9
-
-      case 45:
-      case 48:
-      case 49:
-      case 50:
-      case 51:
-      case 52:
-      case 53:
-      case 54:
-      case 55:
-      case 56:
-      case 57:
-        return readNumber(source, pos, code, line, col, prev);
-      // "
-
-      case 34:
-        if (body.charCodeAt(pos + 1) === 34 && body.charCodeAt(pos + 2) === 34) {
-          return readBlockString(source, pos, line, col, prev, lexer);
-        }
+          ++lexer.line;
+          lexer.lineStart = pos;
+          continue;
+
+        case 33:
+          //  !
+          return new Token(TokenKind.BANG, pos, pos + 1, _line, _col, prev);
+
+        case 35:
+          //  #
+          return readComment(source, pos, _line, _col, prev);
+
+        case 36:
+          //  $
+          return new Token(TokenKind.DOLLAR, pos, pos + 1, _line, _col, prev);
+
+        case 38:
+          //  &
+          return new Token(TokenKind.AMP, pos, pos + 1, _line, _col, prev);
+
+        case 40:
+          //  (
+          return new Token(TokenKind.PAREN_L, pos, pos + 1, _line, _col, prev);
+
+        case 41:
+          //  )
+          return new Token(TokenKind.PAREN_R, pos, pos + 1, _line, _col, prev);
+
+        case 46:
+          //  .
+          if (body.charCodeAt(pos + 1) === 46 && body.charCodeAt(pos + 2) === 46) {
+            return new Token(TokenKind.SPREAD, pos, pos + 3, _line, _col, prev);
+          }
+
+          break;
+
+        case 58:
+          //  :
+          return new Token(TokenKind.COLON, pos, pos + 1, _line, _col, prev);
+
+        case 61:
+          //  =
+          return new Token(TokenKind.EQUALS, pos, pos + 1, _line, _col, prev);
+
+        case 64:
+          //  @
+          return new Token(TokenKind.AT, pos, pos + 1, _line, _col, prev);
+
+        case 91:
+          //  [
+          return new Token(TokenKind.BRACKET_L, pos, pos + 1, _line, _col, prev);
+
+        case 93:
+          //  ]
+          return new Token(TokenKind.BRACKET_R, pos, pos + 1, _line, _col, prev);
+
+        case 123:
+          // {
+          return new Token(TokenKind.BRACE_L, pos, pos + 1, _line, _col, prev);
+
+        case 124:
+          // |
+          return new Token(TokenKind.PIPE, pos, pos + 1, _line, _col, prev);
+
+        case 125:
+          // }
+          return new Token(TokenKind.BRACE_R, pos, pos + 1, _line, _col, prev);
+
+        case 34:
+          //  "
+          if (body.charCodeAt(pos + 1) === 34 && body.charCodeAt(pos + 2) === 34) {
+            return readBlockString(source, pos, _line, _col, prev, lexer);
+          }
+
+          return readString(source, pos, _line, _col, prev);
+
+        case 45: //  -
+
+        case 48: //  0
+
+        case 49: //  1
+
+        case 50: //  2
+
+        case 51: //  3
+
+        case 52: //  4
+
+        case 53: //  5
+
+        case 54: //  6
+
+        case 55: //  7
+
+        case 56: //  8
+
+        case 57:
+          //  9
+          return readNumber(source, pos, code, _line, _col, prev);
+
+        case 65: //  A
+
+        case 66: //  B
+
+        case 67: //  C
+
+        case 68: //  D
+
+        case 69: //  E
+
+        case 70: //  F
+
+        case 71: //  G
+
+        case 72: //  H
+
+        case 73: //  I
+
+        case 74: //  J
+
+        case 75: //  K
+
+        case 76: //  L
+
+        case 77: //  M
+
+        case 78: //  N
+
+        case 79: //  O
+
+        case 80: //  P
+
+        case 81: //  Q
+
+        case 82: //  R
+
+        case 83: //  S
+
+        case 84: //  T
+
+        case 85: //  U
+
+        case 86: //  V
+
+        case 87: //  W
+
+        case 88: //  X
+
+        case 89: //  Y
+
+        case 90: //  Z
+
+        case 95: //  _
+
+        case 97: //  a
 
-        return readString(source, pos, line, col, prev);
+        case 98: //  b
+
+        case 99: //  c
+
+        case 100: // d
+
+        case 101: // e
+
+        case 102: // f
+
+        case 103: // g
+
+        case 104: // h
+
+        case 105: // i
+
+        case 106: // j
+
+        case 107: // k
+
+        case 108: // l
+
+        case 109: // m
+
+        case 110: // n
+
+        case 111: // o
+
+        case 112: // p
+
+        case 113: // q
+
+        case 114: // r
+
+        case 115: // s
+
+        case 116: // t
+
+        case 117: // u
+
+        case 118: // v
+
+        case 119: // w
+
+        case 120: // x
+
+        case 121: // y
+
+        case 122:
+          // z
+          return readName(source, pos, _line, _col, prev);
+      }
+
+      throw syntaxError(source, pos, unexpectedCharacterMessage(code));
     }
 
-    throw syntaxError(source, pos, unexpectedCharacterMessage(code));
+    var line = lexer.line;
+    var col = 1 + pos - lexer.lineStart;
+    return new Token(TokenKind.EOF, bodyLength, bodyLength, line, col, prev);
   }
   /**
    * Report a message that an unexpected character was encountered.
@@ -4190,43 +4408,6 @@ ${queryParams
 
     return "Cannot parse the unexpected character ".concat(printCharCode(code), ".");
   }
-  /**
-   * Reads from body starting at startPosition until it finds a non-whitespace
-   * character, then returns the position of that character for lexing.
-   */
-
-
-  function positionAfterWhitespace(body, startPosition, lexer) {
-    var bodyLength = body.length;
-    var position = startPosition;
-
-    while (position < bodyLength) {
-      var code = body.charCodeAt(position); // tab | space | comma | BOM
-
-      if (code === 9 || code === 32 || code === 44 || code === 0xfeff) {
-        ++position;
-      } else if (code === 10) {
-        // new line
-        ++position;
-        ++lexer.line;
-        lexer.lineStart = position;
-      } else if (code === 13) {
-        // carriage return
-        if (body.charCodeAt(position + 1) === 10) {
-          position += 2;
-        } else {
-          ++position;
-        }
-
-        ++lexer.line;
-        lexer.lineStart = position;
-      } else {
-        break;
-      }
-    }
-
-    return position;
-  }
   /**
    * Reads a comment token from the source file.
    *
@@ -4547,11 +4728,21 @@ ${queryParams
     var parser = new Parser(source, options);
     return parser.parseDocument();
   }
+  /**
+   * This class is exported only to assist people in implementing their own parsers
+   * without duplicating too much code and should be used only as last resort for cases
+   * such as experimental syntax or if certain features could not be contributed upstream.
+   *
+   * It is still part of the internal API and is versioned, so any changes to it are never
+   * considered breaking changes. If you still need to support multiple versions of the
+   * library, please use the `versionInfo` variable for version detection.
+   *
+   * @internal
+   */
 
   var Parser = /*#__PURE__*/function () {
     function Parser(source, options) {
-      var sourceObj = typeof source === 'string' ? new Source(source) : source;
-      sourceObj instanceof Source || devAssert(0, "Must provide Source. Received: ".concat(inspect(sourceObj), "."));
+      var sourceObj = isSource(source) ? source : new Source(source);
       this._lexer = new Lexer(sourceObj);
       this._options = options;
     }
@@ -5296,21 +5487,25 @@ ${queryParams
     ;
 
     _proto.parseImplementsInterfaces = function parseImplementsInterfaces() {
-      var types = [];
+      var _this$_options2;
+
+      if (!this.expectOptionalKeyword('implements')) {
+        return [];
+      }
+
+      if (((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.allowLegacySDLImplementsInterfaces) === true) {
+        var types = []; // Optional leading ampersand
 
-      if (this.expectOptionalKeyword('implements')) {
-        // Optional leading ampersand
         this.expectOptionalToken(TokenKind.AMP);
 
         do {
-          var _this$_options2;
-
           types.push(this.parseNamedType());
-        } while (this.expectOptionalToken(TokenKind.AMP) || // Legacy support for the SDL?
-        ((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.allowLegacySDLImplementsInterfaces) === true && this.peek(TokenKind.NAME));
+        } while (this.expectOptionalToken(TokenKind.AMP) || this.peek(TokenKind.NAME));
+
+        return types;
       }
 
-      return types;
+      return this.delimitedMany(TokenKind.AMP, this.parseNamedType);
     }
     /**
      * FieldsDefinition : { FieldDefinition+ }
@@ -5446,18 +5641,7 @@ ${queryParams
     ;
 
     _proto.parseUnionMemberTypes = function parseUnionMemberTypes() {
-      var types = [];
-
-      if (this.expectOptionalToken(TokenKind.EQUALS)) {
-        // Optional leading pipe
-        this.expectOptionalToken(TokenKind.PIPE);
-
-        do {
-          types.push(this.parseNamedType());
-        } while (this.expectOptionalToken(TokenKind.PIPE));
-      }
-
-      return types;
+      return this.expectOptionalToken(TokenKind.EQUALS) ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType) : [];
     }
     /**
      * EnumTypeDefinition :
@@ -5808,15 +5992,7 @@ ${queryParams
     ;
 
     _proto.parseDirectiveLocations = function parseDirectiveLocations() {
-      // Optional leading pipe
-      this.expectOptionalToken(TokenKind.PIPE);
-      var locations = [];
-
-      do {
-        locations.push(this.parseDirectiveLocation());
-      } while (this.expectOptionalToken(TokenKind.PIPE));
-
-      return locations;
+      return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);
     }
     /*
      * DirectiveLocation :
@@ -5859,8 +6035,7 @@ ${queryParams
     } // Core parsing utility functions
 
     /**
-     * Returns a location object, used to identify the place in
-     * the source that created a given parsed object.
+     * Returns a location object, used to identify the place in the source that created a given parsed object.
      */
     ;
 
@@ -5880,8 +6055,8 @@ ${queryParams
       return this._lexer.token.kind === kind;
     }
     /**
-     * If the next token is of the given kind, return that token after advancing
-     * the lexer. Otherwise, do not change the parser state and throw an error.
+     * If the next token is of the given kind, return that token after advancing the lexer.
+     * Otherwise, do not change the parser state and throw an error.
      */
     ;
 
@@ -5897,8 +6072,8 @@ ${queryParams
       throw syntaxError(this._lexer.source, token.start, "Expected ".concat(getTokenKindDesc(kind), ", found ").concat(getTokenDesc(token), "."));
     }
     /**
-     * If the next token is of the given kind, return that token after advancing
-     * the lexer. Otherwise, do not change the parser state and return undefined.
+     * If the next token is of the given kind, return that token after advancing the lexer.
+     * Otherwise, do not change the parser state and return undefined.
      */
     ;
 
@@ -5929,8 +6104,8 @@ ${queryParams
       }
     }
     /**
-     * If the next token is a given keyword, return "true" after advancing
-     * the lexer. Otherwise, do not change the parser state and return "false".
+     * If the next token is a given keyword, return "true" after advancing the lexer.
+     * Otherwise, do not change the parser state and return "false".
      */
     ;
 
@@ -5946,8 +6121,7 @@ ${queryParams
       return false;
     }
     /**
-     * Helper function for creating an error when an unexpected lexed token
-     * is encountered.
+     * Helper function for creating an error when an unexpected lexed token is encountered.
      */
     ;
 
@@ -5956,10 +6130,9 @@ ${queryParams
       return syntaxError(this._lexer.source, token.start, "Unexpected ".concat(getTokenDesc(token), "."));
     }
     /**
-     * Returns a possibly empty list of parse nodes, determined by
-     * the parseFn. This list begins with a lex token of openKind
-     * and ends with a lex token of closeKind. Advances the parser
-     * to the next lex token after the closing token.
+     * Returns a possibly empty list of parse nodes, determined by the parseFn.
+     * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+     * Advances the parser to the next lex token after the closing token.
      */
     ;
 
@@ -5975,10 +6148,9 @@ ${queryParams
     }
     /**
      * Returns a list of parse nodes, determined by the parseFn.
-     * It can be empty only if open token is missing otherwise it will always
-     * return non-empty list that begins with a lex token of openKind and ends
-     * with a lex token of closeKind. Advances the parser to the next lex token
-     * after the closing token.
+     * It can be empty only if open token is missing otherwise it will always return non-empty list
+     * that begins with a lex token of openKind and ends with a lex token of closeKind.
+     * Advances the parser to the next lex token after the closing token.
      */
     ;
 
@@ -5996,10 +6168,9 @@ ${queryParams
       return [];
     }
     /**
-     * Returns a non-empty list of parse nodes, determined by
-     * the parseFn. This list begins with a lex token of openKind
-     * and ends with a lex token of closeKind. Advances the parser
-     * to the next lex token after the closing token.
+     * Returns a non-empty list of parse nodes, determined by the parseFn.
+     * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+     * Advances the parser to the next lex token after the closing token.
      */
     ;
 
@@ -6011,22 +6182,38 @@ ${queryParams
         nodes.push(parseFn.call(this));
       } while (!this.expectOptionalToken(closeKind));
 
+      return nodes;
+    }
+    /**
+     * Returns a non-empty list of parse nodes, determined by the parseFn.
+     * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+     * Advances the parser to the next lex token after last item in the list.
+     */
+    ;
+
+    _proto.delimitedMany = function delimitedMany(delimiterKind, parseFn) {
+      this.expectOptionalToken(delimiterKind);
+      var nodes = [];
+
+      do {
+        nodes.push(parseFn.call(this));
+      } while (this.expectOptionalToken(delimiterKind));
+
       return nodes;
     };
 
     return Parser;
   }();
   /**
-   * A helper function to describe a token as a string for debugging
+   * A helper function to describe a token as a string for debugging.
    */
 
-
   function getTokenDesc(token) {
     var value = token.value;
     return getTokenKindDesc(token.kind) + (value != null ? " \"".concat(value, "\"") : '');
   }
   /**
-   * A helper function to describe a token kind as a string for debugging
+   * A helper function to describe a token kind as a string for debugging.
    */
 
 
@@ -6055,6 +6242,7 @@ ${queryParams
       };
   }
   function graphQLRequestHandler(expectedOperationType, expectedOperationName, mask, resolver) {
+      const callFrame = getCallFrame();
       return {
           resolver,
           parse(req) {
@@ -6126,6 +6314,17 @@ ${queryParams
               console.log('Response:', loggedResponse);
               console.groupEnd();
           },
+          getMetaInfo() {
+              const header = expectedOperationType === 'all'
+                  ? `[graphql] ${expectedOperationType} (origin: ${mask.toString()})`
+                  : `[graphql] ${expectedOperationType} ${expectedOperationName} (origin: ${mask.toString()})`;
+              return {
+                  type: 'graphql',
+                  header,
+                  mask,
+                  callFrame,
+              };
+          },
       };
   }
   const createGraphQLScopedHandler = (expectedOperationType, mask) => {
@@ -6153,7 +6352,9 @@ ${queryParams
   const graphql = Object.assign(Object.assign({}, graphqlStandardHandlers), { link: createGraphQLLink });
 
   exports.context = index;
+  exports.createResponseComposition = createResponseComposition;
   exports.defaultContext = defaultContext;
+  exports.defaultResponse = defaultResponse;
   exports.graphql = graphql;
   exports.graphqlContext = graphqlContext;
   exports.matchRequestUrl = matchRequestUrl;