if (typeof FastBoot === "undefined") {
  var preferNative = true;
  (function(global) {
    define("fetch", ["exports"], function(self) {
      "use strict";

      var Promise = global.Ember.RSVP.Promise;
      var supportProps = [
        "FormData",
        "FileReader",
        "Blob",
        "URLSearchParams",
        "Symbol",
        "ArrayBuffer"
      ];
      var polyfillProps = [
        "fetch",
        "Headers",
        "Request",
        "Response",
        "AbortController"
      ];
      var combinedProps = supportProps;
      if (preferNative) {
        combinedProps = supportProps.concat(polyfillProps);
      }
      combinedProps.forEach(function(prop) {
        if (global[prop]) {
          Object.defineProperty(self, prop, {
            configurable: true,
            get: function() {
              return global[prop];
            },
            set: function(v) {
              global[prop] = v;
            }
          });
        }
      });

      if (!self.fetch) {
        throw new Error(
          "fetch is not defined - maybe your browser targets are not covering everything you need?"
        );
      }

      var pending = 0;
      function decrement(result) {
        pending--;
        return result;
      }

      if (global.Ember.Test) {
        global.Ember.Test.registerWaiter(function() {
          return pending === 0;
        });

        self["default"] = function() {
          pending++;

          return self.fetch.apply(global, arguments).then(
            function(response) {
              response
                .clone()
                .blob()
                .then(decrement, decrement);
              return response;
            },
            function(reason) {
              decrement(reason);
              throw reason;
            }
          );
        };
      } else {
        self["default"] = self.fetch;
      }
      supportProps.forEach(function(prop) {
        delete self[prop];
      });
    });

    define("fetch/ajax", ["exports"], function() {
      throw new Error(
        "You included `fetch/ajax` but it was renamed to `ember-fetch/ajax`"
      );
    });
  })(
    typeof window !== "undefined"
      ? window
      : typeof global !== "undefined"
      ? global
      : typeof self !== "undefined"
      ? self
      : this
  );
}
define("ember-fetch/ajax", ["exports", "fetch"], function(exports, _fetch) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = ajax;
  function ajax(input, init) {
    return (0, _fetch.default)(input, init).then(response => {
      if (response.ok) {
        return response.json();
      }
      throw response;
    });
  }
});
define("ember-fetch/mixins/adapter-fetch", [
  "exports",
  "fetch",
  "ember-fetch/utils/mung-options-for-fetch",
  "ember-fetch/utils/determine-body-promise"
], function(exports, _fetch, _mungOptionsForFetch, _determineBodyPromise) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.headersToObject = headersToObject;

  /**
   * Helper function to create a plain object from the response's Headers.
   * Consumed by the adapter's `handleResponse`.
   */
  function headersToObject(headers) {
    let headersObject = {};
    if (headers) {
      headers.forEach((value, key) => (headersObject[key] = value));
    }
    return headersObject;
  }
  exports.default = Ember.Mixin.create({
    headers: undefined,
    /**
     * @override
     */
    ajaxOptions(url, type, options) {
      let hash = options || {};
      hash.url = url;
      hash.type = type;
      // Add headers set on the Adapter
      let adapterHeaders = Ember.get(this, "headers");
      if (adapterHeaders) {
        hash.headers = Ember.assign(hash.headers || {}, adapterHeaders);
      }
      const mungedOptions = (0, _mungOptionsForFetch.default)(hash);
      // Mimics the default behavior in Ember Data's `ajaxOptions`, namely to set the
      // 'Content-Type' header to application/json if it is not a GET request and it has a body.
      if (
        mungedOptions.method !== "GET" &&
        mungedOptions.body &&
        (mungedOptions.headers === undefined ||
          !(
            mungedOptions.headers["Content-Type"] ||
            mungedOptions.headers["content-type"]
          ))
      ) {
        mungedOptions.headers = mungedOptions.headers || {};
        mungedOptions.headers["Content-Type"] =
          "application/json; charset=utf-8";
      }
      return mungedOptions;
    },
    /**
     * @override
     */
    ajax(url, type, options) {
      const requestData = {
        url,
        method: type
      };
      const hash = this.ajaxOptions(url, type, options);
      return (
        this._ajaxRequest(hash)
          // @ts-ignore
          .catch((error, response, requestData) => {
            throw this.ajaxError(this, response, null, requestData, error);
          })
          .then(response => {
            return Ember.RSVP.hash({
              response,
              payload: (0, _determineBodyPromise.default)(response, requestData)
            });
          })
          .then(({ response, payload }) => {
            if (response.ok) {
              return this.ajaxSuccess(this, response, payload, requestData);
            } else {
              throw this.ajaxError(this, response, payload, requestData);
            }
          })
      );
    },
    /**
     * Overrides the `_ajaxRequest` method to use `fetch` instead of jQuery.ajax
     * @override
     */
    _ajaxRequest(options) {
      return this._fetchRequest(options.url, options);
    },
    /**
     * A hook into where `fetch` is called.
     * Useful if you want to override this behavior, for example to multiplex requests.
     */
    _fetchRequest(url, options) {
      return (0, _fetch.default)(url, options);
    },
    /**
     * @override
     */
    ajaxSuccess(adapter, response, payload, requestData) {
      const returnResponse = adapter.handleResponse(
        response.status,
        headersToObject(response.headers),
        // TODO: DS.RESTAdapter annotates payload: {}
        // @ts-ignore
        payload,
        requestData
      );
      // TODO: DS.RESTAdapter annotates response: {}
      // @ts-ignore
      if (returnResponse && returnResponse.isAdapterError) {
        return Ember.RSVP.reject(returnResponse);
      } else {
        return returnResponse;
      }
    },
    /**
     * Allows for the error to be selected from either the
     * response object, or the response data.
     */
    parseFetchResponseForError(response, payload) {
      return payload || response.statusText;
    },
    /**
     * @override
     */
    ajaxError(adapter, response, payload, requestData, error) {
      if (error) {
        return error;
      } else {
        const parsedResponse = adapter.parseFetchResponseForError(
          response,
          payload
        );
        return adapter.handleResponse(
          response.status,
          headersToObject(response.headers),
          // TODO: parseErrorResponse is DS.RESTAdapter private API
          // @ts-ignore
          adapter.parseErrorResponse(parsedResponse) || payload,
          requestData
        );
      }
    }
  });
});
define("ember-fetch/types", ["exports"], function(exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.isPlainObject = isPlainObject;
  function isPlainObject(obj) {
    return Object.prototype.toString.call(obj) === "[object Object]";
  }
});
define("ember-fetch/utils/determine-body-promise", ["exports"], function(
  exports
) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = determineBodyPromise;
  /**
   * Function that always attempts to parse the response as json, and if an error is thrown,
   * returns `undefined` if the response is successful and has a status code of 204 (No Content),
   * or 205 (Reset Content) or if the request method was 'HEAD', and the plain payload otherwise.
   */
  function determineBodyPromise(response, requestData) {
    return response.text().then(function(payload) {
      let ret = payload;
      try {
        ret = JSON.parse(payload);
      } catch (error) {
        if (!(error instanceof SyntaxError)) {
          throw error;
        }
        const status = response.status;
        if (
          response.ok &&
          (status === 204 || status === 205 || requestData.method === "HEAD")
        ) {
          ret = undefined;
        } else {
          console.warn(
            "This response was unable to be parsed as json.",
            payload
          );
        }
      }
      return ret;
    });
  }
});
define("ember-fetch/utils/mung-options-for-fetch", [
  "exports",
  "ember-fetch/utils/serialize-query-params",
  "ember-fetch/types"
], function(exports, _serializeQueryParams, _types) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = mungOptionsForFetch;

  /**
   * Helper function that translates the options passed to `jQuery.ajax` into a format that `fetch` expects.
   */
  function mungOptionsForFetch(options) {
    const hash = Ember.assign(
      {
        credentials: "same-origin"
      },
      options
    );
    // Default to 'GET' in case `type` is not passed in (mimics jQuery.ajax).
    hash.method = (hash.method || hash.type || "GET").toUpperCase();
    if (hash.data) {
      // GET and HEAD requests can't have a `body`
      if (hash.method === "GET" || hash.method === "HEAD") {
        // If no options are passed, Ember Data sets `data` to an empty object, which we test for.
        if (Object.keys(hash.data).length) {
          // Test if there are already query params in the url (mimics jQuey.ajax).
          const queryParamDelimiter = hash.url.indexOf("?") > -1 ? "&" : "?";
          hash.url += `${queryParamDelimiter}${(0,
          _serializeQueryParams.serializeQueryParams)(hash.data)}`;
        }
      } else {
        // NOTE: a request's body cannot be a POJO, so we stringify it if it is.
        // JSON.stringify removes keys with values of `undefined` (mimics jQuery.ajax).
        // If the data is not a POJO (it's a String, FormData, etc), we just set it.
        // If the data is a string, we assume it's a stringified object.
        if ((0, _types.isPlainObject)(hash.data)) {
          hash.body = JSON.stringify(hash.data);
        } else {
          hash.body = hash.data;
        }
      }
    }
    return hash;
  }
});
define("ember-fetch/utils/serialize-query-params", [
  "exports",
  "ember-fetch/types"
], function(exports, _types) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.serializeQueryParams = serializeQueryParams;

  const RBRACKET = /\[\]$/;
  /**
   * Helper function that turns the data/body of a request into a query param string.
   * This is directly copied from jQuery.param.
   */
  function serializeQueryParams(queryParamsObject) {
    var s = [];
    function buildParams(prefix, obj) {
      var i, len, key;
      if (prefix) {
        if (Array.isArray(obj)) {
          for (i = 0, len = obj.length; i < len; i++) {
            if (RBRACKET.test(prefix)) {
              add(s, prefix, obj[i]);
            } else {
              buildParams(
                prefix + "[" + (typeof obj[i] === "object" ? i : "") + "]",
                obj[i]
              );
            }
          }
        } else if ((0, _types.isPlainObject)(obj)) {
          for (key in obj) {
            buildParams(prefix + "[" + key + "]", obj[key]);
          }
        } else {
          add(s, prefix, obj);
        }
      } else if (Array.isArray(obj)) {
        for (i = 0, len = obj.length; i < len; i++) {
          add(s, obj[i].name, obj[i].value);
        }
      } else {
        for (key in obj) {
          buildParams(key, obj[key]);
        }
      }
      return s;
    }
    return buildParams("", queryParamsObject)
      .join("&")
      .replace(/%20/g, "+");
  }
  /**
   * Part of the `serializeQueryParams` helper function.
   */
  function add(s, k, v) {
    // Strip out keys with undefined value and replace null values with
    // empty strings (mimics jQuery.ajax)
    if (v === undefined) {
      return;
    } else if (v === null) {
      v = "";
    }
    v = typeof v === "function" ? v() : v;
    s[s.length] = `${encodeURIComponent(k)}=${encodeURIComponent(v)}`;
  }
  exports.default = serializeQueryParams;
});