docs: function () {
                  // Read response state from the memoized partial data.
                  var _a = partialFromXhr(), headers = _a.headers, status = _a.status, statusText = _a.statusText, url = _a.url;
                  // The body will be read out if present.
                  var body = null;
                  if (status !== 204) {
                      // Use XMLHttpRequest.response if set, responseText otherwise.
                      body = (typeof xhr.response === 'undefined') ? xhr.responseText : xhr.response;
                  }
                  // Normalize another potential bug (this one comes from CORS).
                  if (status === 0) {
                      status = !!body ? 200 : 0;
                  }
                  // ok determines whether the response will be transmitted on the event or
                  // error channel. Unsuccessful status codes (not 2xx) will always be errors,
                  // but a successful status code can still result in an error if the user
                  // asked for JSON data and the body cannot be parsed as such.
                  var ok = status >= 200 && status < 300;
                  // Check whether the body needs to be parsed as JSON (in many cases the browser
                  // will have done that already).
                  if (req.responseType === 'json' && typeof body === 'string') {
                      // Save the original body, before attempting XSSI prefix stripping.
                      var originalBody = body;
                      body = body.replace(XSSI_PREFIX, '');
                      try {
                          // Attempt the parse. If it fails, a parse error should be delivered to the user.
                          body = body !== '' ? JSON.parse(body) : null;
                      }
                      catch (error) {
                          // Since the JSON.parse failed, it's reasonable to assume this might not have been a
                          // JSON response. Restore the original body (including any XSSI prefix) to deliver
                          // a better error response.
                          body = originalBody;
                          // If this was an error request to begin with, leave it as a string, it probably
                          // just isn't JSON. Otherwise, deliver the parsing error to the user.
                          if (ok) {
                              // Even though the response status was 2xx, this is still an error.
                              ok = false;
                              // The parse error contains the text of the body that failed to parse.
                              body = { error: error, text: body };
                          }
                      }
                  }
                  if (ok) {
                      // A successful response is delivered on the event stream.
                      observer.next(new HttpResponse({
                          body: body,
                          headers: headers,
                          status: status,
                          statusText: statusText,
                          url: url || undefined,
                      }));
                      // The full body has been received and delivered, no further events
                      // are possible. This request is complete.
                      observer.complete();
                  }
                  else {
                      // An unsuccessful request is delivered on the error channel.
                      observer.error(new HttpErrorResponse({
                          // The error in this case is the response body (error from the server).
                          error: body,
                          headers: headers,
                          status: status,
                          statusText: statusText,
                          url: url || undefined,
                      }));
                  }
              }